diff --git a/.codecov.yml b/.codecov.yml index 9ec352888..e10eb4a78 100644 --- a/.codecov.yml +++ b/.codecov.yml @@ -1,4 +1,5 @@ comment: false + coverage: status: project: @@ -9,6 +10,9 @@ coverage: default: target: 0% # the (on purpose low) required coverage value +ignore: + - 'R/inline.R' # function factory setup confuses codecov + # layout: "header, diff, tree, changes" # behavior: default # require_changes: false # if true: only post the comment if coverage changes diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml index f0cd2dedf..ff9bc220f 100644 --- a/.github/workflows/ci.yaml +++ b/.github/workflows/ci.yaml @@ -25,6 +25,9 @@ jobs: - name: release cntr: rcpp/ci r: R + - name: r-4.4 + cntr: rcpp/ci-4.4 + r: R - name: r-4.3 cntr: rcpp/ci-4.3 r: R @@ -48,13 +51,7 @@ jobs: r: RD steps: - - uses: actions/checkout@v3 - - #- name: Bootstrap - # run: | - # curl -OLs https://eddelbuettel.github.io/r-ci/run.sh - # chmod 0755 run.sh - # ./run.sh bootstrap + - uses: actions/checkout@v5 - name: SessionInfo run: ${{ matrix.r }} -q -e 'sessionInfo()' @@ -65,14 +62,19 @@ jobs: - name: Check run: CI=true ${{ matrix.r }} CMD check --no-vignettes --no-manual Rcpp_*.tar.gz - #covr: - # runs-on: ubuntu-latest - # steps: - # - name: Checkout Project - # uses: actions/checkout@v3 - # - # - name: Container - # run: docker pull rcpp/ci - # - # - name: Coverage - # run: docker run --rm -i -v ${PWD}:/mnt -w /mnt -e CODECOV_TOKEN=${{secrets.CODECOV_TOKEN }} rcpp/ci r -l covr -e 'codecov()' + covr: + runs-on: ubuntu-latest + steps: + - name: Checkout Project + uses: actions/checkout@v5 + + - name: Setup + uses: eddelbuettel/github-actions/r-ci@master + + - name: Dependencies + run: ./run.sh install_deps + + - name: Coverage + env: + CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} + run: ./run.sh coverage diff --git a/.github/workflows/docker.yaml b/.github/workflows/docker.yaml index dd6fc6541..5ac954e67 100644 --- a/.github/workflows/docker.yaml +++ b/.github/workflows/docker.yaml @@ -4,6 +4,7 @@ on: push: branches: - master + workflow_dispatch: schedule: - cron: "32 1 * * 6" @@ -19,7 +20,7 @@ jobs: steps: - name: Checkout - uses: actions/checkout@v3 + uses: actions/checkout@v6 - name: Set up Docker Buildx uses: docker/setup-buildx-action@v2 diff --git a/.github/workflows/linuxarm.yaml b/.github/workflows/linuxarm.yaml new file mode 100644 index 000000000..fa328c13b --- /dev/null +++ b/.github/workflows/linuxarm.yaml @@ -0,0 +1,38 @@ +# Run CI for R using https://eddelbuettel.github.io/r-ci/ + +name: linuxarm + +on: + #push: + #pull_request: + workflow_dispatch: + +env: + _R_CHECK_FORCE_SUGGESTS_: "false" + +jobs: + ci: + strategy: + matrix: + include: + #- {os: ubuntu-latest} + - {os: ubuntu-24.04-arm} + + runs-on: ${{ matrix.os }} + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup + uses: eddelbuettel/github-actions/r-ci@master + + - name: Dependencies + run: ./run.sh install_deps + + - name: Test + run: ./run.sh run_tests + + #- name: Coverage + # if: ${{ matrix.os == 'ubuntu-latest' }} + # run: ./run.sh coverage diff --git a/.github/workflows/macos.yaml b/.github/workflows/macos.yaml new file mode 100644 index 000000000..373f3462e --- /dev/null +++ b/.github/workflows/macos.yaml @@ -0,0 +1,39 @@ +# Run CI for R using https://eddelbuettel.github.io/r-ci/ + +name: macos + +on: + push: + pull_request: + +env: + _R_CHECK_FORCE_SUGGESTS_: "false" + +jobs: + ci: + strategy: + matrix: + include: + - {os: macos-latest} + - {os: macos-14} + #- {os: ubuntu-latest} + #- {os: ubuntu-24.04-arm} + + runs-on: ${{ matrix.os }} + + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup + uses: eddelbuettel/github-actions/r-ci@master + + - name: Dependencies + run: ./run.sh install_deps + + - name: Test + run: ./run.sh run_tests + + #- name: Coverage + # if: ${{ matrix.os == 'ubuntu-latest' }} + # run: ./run.sh coverage diff --git a/ChangeLog b/ChangeLog index 6a7c7bd3e..6617de751 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,833 @@ +2026-04-23 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Update one arXiv URL + * inst/bib/Rcpp.bib: Idem + * vignettes/Rcpp-libraries.pdf: Regenerated + +2026-04-13 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2026-04-12 Dirk Eddelbuettel + + * inst/include/Rcpp/Nullable.h (Nullable): 'operator T()' is now + behind an opt-in #define + +2026-04-09 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/Nullable.h (T): Also add 'operator T()' + (conditional on R (>= 4.3.0) as older versions croak) + +2026-04-08 Dirk Eddelbuettel + + * inst/include/Rcpp/Nullable.h (as): Enhance by adding an explicit + Rcpp::as() aiding cases where implicit as<> does not suffice + +2026-04-07 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date (twice) + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Stress interim status + +2026-04-06 Iñaki Ucar + + * inst/tinytest/test_vector.R: Complete test cases for setting NamesProxy + * inst/tinytest/cpp/Vector.cpp: Idem + +2026-04-02 Dirk Eddelbuettel + + * inst/include/Rcpp/Function.h: Further refinement for 4.6.0 to not + require R_NamespaceRegistry, using R_getRegisteredNamespace() instead + +2026-04-03 Dirk Eddelbuettel + + * inst/include/Rcpp/proxy/NamesProxy.h (set): Only set non-null values + +2026-04-01 Mattias Ellert + + * inst/discovery/cxx0x.R: Set execute permissions for script + with shebang + * inst/examples/ConvolveBenchmarks/overhead.r: Idem + * inst/examples/ConvolveBenchmarks/overhead.sh: Idem + * inst/examples/Misc/ifelseLooped.r: Idem + * inst/examples/Misc/newFib.r: Idem + * inst/examples/OpenMP/OpenMPandInline.r: Idem + * inst/tinytest/test_dispatch.R: Idem + +2026-03-29 Iñaki Ucar + + * inst/include/Rcpp/api/meat/Rcpp_eval.h: Remove check for non-API + R_UnboundValue, which is never returned anyway from Rf_findFun + * inst/include/Rcpp/Function.h: Use alternative to R_UnboundValue + * inst/include/Rcpp/Promise.h: Idem + * inst/include/Rcpp/Environment.h: Idem + some refactoring + +2026-03-26 Iñaki Ucar + + * inst/include/Rcpp/internal/r_vector.h: Use dataptr() again to avoid an + invalid pointer for empty vectors, which causes UB in e.g. std::copy + * inst/tinytest/test_vector.R: Add tests for std::copy + * inst/tinytest/cpp/Vector.cpp: Idem +2026-03-27 Iñaki Ucar + + * inst/include/Rcpp/vector/ListOf.h: Fix inheritance + * inst/include/Rcpp/proxy/NamesProxy.h: Fix compatibility + +2026-03-26 Dirk Eddelbuettel + + * inst/bib/Rcpp.bib: Refreshed a few more references + +2026-03-06 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date (twice) + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Updated + + * inst/include/Rcpp/Environment.h: For R 4.5.0 or later, use + R_ParentEnv instead of ENCLOS to reach parent environment + +2026-02-27 Iñaki Ucar + + * inst/include/Rcpp/sugar/functions/max.h: Fix UB for empty integer + * inst/include/Rcpp/sugar/functions/min.h: Idem + * inst/tinytest/test_sugar.R: Adapt tests + +2026-02-26 Iñaki Ucar + + * inst/include/Rcpp/sugar/tools/safe_math.h: New header implementing safe + versions of add/sub/mul operations for integral types + * inst/include/Rcpp/sugar/sugar.h: Includes the previous header + + * inst/include/Rcpp/sugar/functions/cumprod.h: Use the previous operations + * inst/include/Rcpp/sugar/functions/cumsum.h: Idem + * inst/include/Rcpp/sugar/functions/diff.h: Idem, also fixed a bug where + the diff was recomputed instead of returning the calculated value + * inst/include/Rcpp/sugar/functions/rowSums.h: Idem + * inst/include/Rcpp/sugar/functions/sum.h: Idem + * inst/include/Rcpp/sugar/operators/minus.h: Idem, also fixed a bug for + an incorrect Extractor specialization in Minus_Primitive_Vector + * inst/include/Rcpp/sugar/operators/plus.h: Idem + * inst/include/Rcpp/sugar/operators/times.h: Idem + + * inst/tinytest/test_sugar.R: New tests covering the new operations + * inst/tinytest/cpp/sugar.cpp: Idem + * inst/tinytest/cpp/sugar_safe_math.cpp: Idem + * inst/tinytest/cpp/sugar_safe_math_fallback.cpp: Idem + +2026-02-17 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Updated + +2026-02-17 Iñaki Ucar + + * inst/include/Rcpp/sugar/operators/Comparator_With_One_Value.h: Fix UB + for non-integer RTYPEs in comparator + +2026-01-23 Dirk Eddelbuettel + + * inst/include/Rcpp/DataFrame.h (nrow): Use R_nrow() with R >= 4.6.0 + * inst/include/Rcpp/proxy/AttributeProxy.h (attributeNames): Use + R_getAttribNames() with R >= 4.6.0; + * inst/include/Rcpp/proxy/AttributeProxy.h (hasAttribute): Use + R_hasAttrib with R >= 4.6.0 + +2026-01-22 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2026-01-21 Dirk Eddelbuettel + + * inst/include/Rcpp/date_datetime/Datetime.h: Fractional seconds type + switched to 'int' for consistency, print format string re-adjusted + +2026-01-20 Dirk Eddelbuettel + + * inst/include/Rcpp/date_datetime/Datetime.h (format): Correct a + format string reflecting 'unsigned int' rather than 'int' + +2026-01-13 Dirk Eddelbuettel + + * inst/tinytest/cpp/attributes_extended.cpp: New unit tests + * inst/tinytest/test_attributes_extended.R: Idem + * inst/tinytest/test_compile_attributes_errors.R: Idem + * inst/tinytest/test_cppfunction_errors.R: Idem + * inst/tinytest/test_sourcecpp_errors.R: Idem + * R/Attributes.R: Remove #nocov tags + * src/attributes.cpp: Idem + +2026-01-12 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/exceptions_impl.h: Combine previous and current + methods enabling when 'execinfo.h' is found on selected platforms + +2026-01-08 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.1.1 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + +2026-01-07 Dirk Eddelbuettel + + * vignettes/pdf/*: Rebuilt + + * vignettes/rmd/Rcpp.bib: Updates to several URLs + * inst/bib/Rcpp.bib: Idem + * vignettes/rmd/*: Idem + * README.md: Idem + +2026-01-06 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * vignettes/rmd/Rcpp.bib: Update package versions dates + * inst/bib/Rcpp.bib: Idem + +2026-01-04 Dirk Eddelbuettel + + * inst/include/RcppCommon.h: No longer require RCPP_USING_UNWIND_PROTECT + * inst/include/Rcpp/r/headers.h: Idem + * inst/include/Rcpp/api/meat/Rcpp_eval.h: Idem + * inst/tinytest/cpp/stack.cpp: No longer test with RCPP_USING_UNWIND_PROTECT + * inst/tinytest/test_interface.R: Idem + +2026-01-01 Dirk Eddelbuettel + + * R/Attributes.R: Additional or adjusted #nocov tags + * R/Rcpp.package.skeleton.R: Idem + * R/RcppLdpath.R: Idem + * R/asis.R: Idem + * R/inline.R: Idem + * inst/include/Rcpp/api/meat/Rcpp_eval.h: Idem + * inst/include/Rcpp/internal/caster.h: Idem + * inst/include/Rcpp/internal/export.h: Idem + * inst/include/Rcpp/proxy/NamesProxy.h: Idem + * inst/include/Rcpp/proxy/SlotProxy.h: Idem + * inst/include/Rcpp/vector/Vector.h: Idem + * inst/include/Rcpp/vector/proxy.h: Idem + * inst/include/Rcpp/vector/traits.h: Idem + * inst/include/Rcpp/Environment.h: Idem + * inst/include/Rcpp/Function.h: Idem + * inst/include/Rcpp/Module.h: Idem + * inst/include/Rcpp/S4.h: Idem + * inst/include/Rcpp/as.h: Idem + * inst/include/Rcpp/exceptions.h: Idem + * inst/include/Rcpp/r_cast.h: Idem + * src/attributes.cpp: Idem + * src/barrier.cpp: Idem + +2025-12-30 Dirk Eddelbuettel + + * tests/tinytest.R: Refine decision of when not to run all tests even + when development version number is seen + +2025-12-28 Dirk Eddelbuettel + + * README.md: Replace installation from drat section with r-universe + +2025-12-22 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/DataFrame.h (nrow): Simplified per #1430 discussion + relying on compact sequence representation removing use of ATTRIB + * inst/include/Rcpp/proxy/AttributeProxy.h (hasAttribute): For R + 4.6.0, rewritten using R_mapAttrib() avoiding to-be-removed ATTRIB() + +2025-12-21 Dirk Eddelbuettel + + * .github/workflows/docker.yaml: Add workflow_dispatch, update + checkout action + +2025-12-19 Dirk Eddelbuettel + + * man/RcppUnitTests.Rd: Removed outdated help page + +2025-12-17 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * DESCRIPTION (Depends): Add 'R (>= 3.5.0)' + +2025-12-16 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * src/barrier.cpp (dataptr): Remove check for 'R (>= 3.5.0)' + * inst/include/Rcpp/Rmath.h: Remove check for 'R (>= 3.1.2)' + * inst/include/Rcpp/Symbol.h: Remove check for 'R (>= 3.2.0)' + * inst/include/Rcpp/exceptions.h: Remove check for 'R (>= 3.5.0)' + * inst/include/Rcpp/r/headers.h: Idem + + * R/Attributes.R: Remove multiple checks for R version < 3.5.0 + * R/Rcpp.package.skeleton.R: Idem + * inst/tinytest/testRcppInterfaceUser/tests/tests.R: Remove one check + +2025-12-12 Dirk Eddelbuettel + + * inst/tinytest/test_system.R: Wrap suppressMessages() around three + tests for long-obsolete linker and compiler flags + + * inst/include/Rcpp/Environment.h: Replace use of Rf_findVarInFrame + with R_getVarEx (or R_getVar) if R 4.5.0 or later is used + * inst/include/Rcpp/Function.h: Idem + * src/barrier.cpp: Idem + +2025-12-10 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/Rmath.h: Do not access Rf_rnbeta + * inst/include/Rcpp/sugar/undoRmath.h: Remove #undef + +2025-12-06 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Updated + +2025-12-04 Iñaki Ucar + + * inst/include/Rcpp/r/headers.h: Include + * inst/include/RcppCommon.h: Drop , not used anymore + and dropped from the API; drop , included above + * src/api.cpp: Drop , dropped from the API + +2025-12-03 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-12-02 Dirk Eddelbuettel + + * R/loadRcppModules.R: Remove file with function deprecated years ago + * man/loadRcppModules-deprecated.Rd: Idem + * NAMESPACE: Remove reference to loadRcppModules() + * man/loadModule.Rd: Idem + * man/Rcpp-deprecated.Rd: Idem + * vignettes/rmd/Rcpp-modules.Rmd: Idem + +2025-12-01 Kevin Ushey + + * R/Attributes.R: Update OpenMP plugin for macOS + +2025-11-29 Dirk Eddelbuettel + + * R/RcppLdpath.R: Revisit deprecation warnings via 'message()' to be + turned into warning or deprecation in 12 or more months 'when suitable' + +2025-11-24 Dirk Eddelbuettel + + * inst/include/Rcpp/r/check_r_headers.h: Add RCPP_NO_R_HEADERS_CHECK + override to skip new check + +2025-11-23 Dirk Eddelbuettel + + * inst/include/Rcpp/r/check_r_headers.h: New header to check if R.h + or related R headers were installed first + * inst/include/RcppCommon.h: Call new header as first thing + +2025-11-12 Iñaki Ucar + + * inst/include/Rcpp/macros/mask.h: Lay the ground for Rf_error masking + with a warning at compilation time unless RCPP_NO_MASK_RF_ERROR is defined + * inst/include/RcppCommon.h: Include the previous file in the last place + * src/attributes.cpp: Use parentheses to protect call to Rf_error + * inst/tinytest/cpp/stack.cpp: Idem + * inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp: Idem + +2025-11-04 Dirk Eddelbuettel + + * .github/workflows/macos.yaml (jobs): Roll macos-13 to macos-14 + +2025-11-01 Iñaki Ucar + + * inst/include/Rcpp/hash/IndexHash.h: Normalize values for all comparisons + * inst/include/Rcpp/hash/SelfHash.h: Idem + * inst/tinytest/test_sugar.R: Add test for signed zeroes + +2025-10-21 Iñaki Ucar + + * inst/include/Rcpp/exceptions_impl.h: Use __has_include to simplify checks + to enable demangling, making them robust for more platforms + +2025-10-13 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/tinytest/test_sugar.R: Simplify and generalize the August fix + as we no longer need to control for R-devel which has been corrected + +2025-09-04 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/internal/wrap.h (make_charsexp__impl__cstring): + Avoid a narrowing warning by casting explicitly + +2025-08-26 Dirk Eddelbuettel + + * inst/tinytest/test_sugar.R: For r-devel, use apply(x, DIM, mean, + na.rm=TRUE) instead of (row|col)Means for complex NA valued matrices + +2025-08-24 Dirk Eddelbuettel + + * .github/workflows/ci.yaml (jobs): Re-enable coverage, roll checkout + action to v5 + + * inst/tinytest/test_sugar.R: For now, park two tests of complex + matrix row and col means under R-devel, this could be a R-devel issue + +2025-07-20 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * R/compilerCheck.R: Remove unused function + * man/compilerCheck.Rd: Remove its documentation + +2025-07-19 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Use DOI for R citation + * inst/bib/Rcpp.bib: Idem + +2025-07-18 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * R/asis.R (asisWeave, asisTangle): Borrowed with thanks from R.rsp + and shortened / simplified to provide 'asis' vignette processor + * R/zzz.R (.onLoad): Register new vignette processor + * vignettes/*.asis: New files with vignette info from .Rnw files + * vignettes/pdf/*.pdf: Moved to directory vignettes/ + * vignettes/*.Rnw: Removed + * man/asisWeave.Rd: Documentation + +2025-07-01 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.1.0 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + +2025-06-25 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-06-18 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Use doi references for CRAN packages, + update versions, update some package titles + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Re-rendered + +2025-06-05 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-06-02 Kevin Ushey + + * inst/include/Rcpp.h: Avoid copy when creating Language objects + * inst/include/Rcpp/Language.h: Idem + * inst/include/Rcpp/lgrow.h: Idem + * inst/tinytest/cpp/language.cpp: Idem + * inst/tinytest/test_language.R: Idem + +2025-05-27 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-05-23 Dirk Eddelbuettel + + * inst/include/Rcpp/date_datetime/newDateVector.h: Add default + constructor + * inst/include/Rcpp/date_datetime/newDatetimeVector.h: Idem + + * inst/tinytest/test_date.R: Add tests + * inst/tinytest/cpp/dates.cpp: Idem + +2025-05-06 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * R/Attributes.R: Support C++26 via plugin + +2025-05-05 Dirk Eddelbuettel + + * inst/tinytest/test_sugar.R: Condition four NA-related tests away on + arm64 on Linux too + + * .github/workflows/linuxarm.yaml (jobs): Add ubuntu-24.04-arm as + optional workflow_dispatch run + +2025-04-15 Dirk Eddelbuettel + + * docker/ci-4.4/Dockerfile: Added based on r-base:4.4.3 + * .github/workflows/ci.yaml (jobs): Add rcpp/ci-4.4 to matrix + +2025-03-31 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-03-29 Iñaki Ucar + + * inst/include/Rcpp/traits/result_of.h: Reimplement traits::result_of using + std::result_of (up to C++14) or std::invoke_result (C++17 or later), which + supports previous use cases and enables lambdas + * inst/include/Rcpp/sugar/functions/sapply.h: Use new result_of interface + * inst/include/Rcpp/sugar/functions/lapply.h: Idem + * inst/include/Rcpp/sugar/functions/mapply/mapply_2.h: Idem + * inst/include/Rcpp/sugar/functions/mapply/mapply_3.h: Idem + * inst/include/Rcpp/sugar/matrix/outer.h: Idem + * inst/tinytest/cpp/sugar.cpp: New tests for previous sugar functions + * inst/tinytest/test_sugar.R: Idem + +2025-03-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-03-26 Iñaki Ucar + + * inst/include/Rcpp/platform/compiler.h: Remove definitions of + RCPP_USING_UNORDERED_MAP and RCPP_USING_UNORDERED_SET + * inst/include/Rcpp/sugar/sets.h: Remove redefinition of macros + * inst/include/Rcpp/sugar/functions/self_match.h: Replace macros with + std::unordered_map and std::unordered_set respectively + * inst/include/Rcpp/sugar/functions/setdiff.h: Idem + * inst/include/Rcpp/sugar/functions/table.h: Idem + * inst/tinytest/cpp/wrap.cpp: Idem + +2025-03-24 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-03-24 Iñaki Ucar + + * inst/include/Rcpp/exceptions.h: Include C+11 variadic template definitions + unconditionally + * inst/include/Rcpp/exceptions/cpp11/exceptions.h: Removed + * inst/include/Rcpp/exceptions/cpp98/exceptions.h: Idem + + * src/attributes.cpp: Remove obsolete pre-C+11 paths based on __cplusplus + define checks + * inst/tinytest/cpp/sugar.cpp: Idem + * inst/include/Rcpp/Language.h: Idem + * inst/include/Rcpp/StringTransformer.h: Idem + * inst/include/Rcpp/algorithm.h: Idem + * inst/include/Rcpp/utils/tinyformat.h: Idem + * inst/include/Rcpp/longlong.h: Idem, unconditional RCPP_HAS_LONG_LONG_TYPES + + * src/api.cpp: Remove explicit RCPP_HAS_LONG_LONG_TYPES as availability is + both implicit and ensured + * inst/include/Rcpp/algorithm.h: Idem + * inst/include/Rcpp/traits/is_arithmetic.h: Idem + * inst/include/Rcpp/traits/longlong.h: Idem + +2025-03-21 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/String.h: Remove explicit RCPP_USING_CXX11 as + use of C++11 (or newer) is both implicit and ensured + * inst/include/Rcpp/macros/dispatch.h: Idem + * inst/include/Rcpp/platform/compiler.h: Idem + * inst/include/Rcpp/unwindProtect.h: Idem + * inst/tinytest/cpp/wrap.cpp: Idem + * src/api.cpp: Idem + +2025-03-18 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/module/class.h: Use variadic templates unconditionally + * inst/include/Rcpp/grow.h: Idem + * inst/include/Rcpp/DottedPair.h: Idem + * inst/include/Rcpp/Vector.h: Idem + * inst/include/Rcpp/Function.h: Idem + * inst/include/Rcpp/internal/call.h: Idem + * inst/include/Rcpp/InternalFunctionWithStdFunction.h: Idem + * inst/include/Rcpp/Module.h: Idem + * inst/include/Rcpp/traits/index_sequence.h: Idem + * inst/include/Rcpp/traits/named_object.h: Idem + * inst/include/Rcpp/Language.h: Idem + * inst/include/Rcpp/DataFrame.h: Idem + * inst/include/Rcpp/PairList.h: Idem + * inst/include/Rcpp/InternalFunction.h: Idem + + * inst/include/Rcpp/module/Module_generated_class_constructor.h: Removed + * inst/include/Rcpp/module/Module_generated_class_factory.h: Idem + * inst/include/Rcpp/module/Module_generated_method.h: Idem + * inst/include/Rcpp/module/Module_generated_Pointer_method.h: Idem + * inst/include/Rcpp/generated/grow__pairlist.h: Idem + * inst/include/Rcpp/generated/DottedPair__ctors.h: Idem + * inst/include/Rcpp/generated/Vector__create.h: Idem + * inst/include/Rcpp/generated/Function__operator.h: Idem + * inst/include/Rcpp/generated/InternalFunctionWithStdFunction_call.h: Idem + * inst/include/Rcpp/module/Module_generated_Constructor.h: Idem + * inst/include/Rcpp/module/Module_generated_CppFunction.h: Idem + * inst/include/Rcpp/module/Module_generated_CppMethod.h: Idem + * inst/include/Rcpp/module/Module_generated_Factory.h: Idem + * inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h: Idem + * inst/include/Rcpp/module/Module_generated_class_signature.h: Idem + * inst/include/Rcpp/module/Module_generated_ctor_signature.h: Idem + * inst/include/Rcpp/module/Module_generated_function.h: Idem + * inst/include/Rcpp/module/Module_generated_get_signature.h: Idem + * inst/include/Rcpp/generated/Language__ctors.h: Idem + * inst/include/Rcpp/generated/DataFrame_generated.h: Idem + * inst/include/Rcpp/generated/Pairlist__ctors.h: Idem + * inst/include/Rcpp/generated/InternalFunction__ctors.h: Idem + + * inst/include/Rcpp/platform/compiler.h: No longer define HAS_VARIADIC_TEMPLATES + * src/api.cpp (rcpp_can_use_cxx0x): Return true unconditionally + +2025-03-15 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/platform/compiler.h: Simplified and shortened + establishing C++11 as baseline; further PRs to complete this + * inst/include/Rcpp/String.h: Unconditionally use std::hash with C++11 + * inst/include/Rcpp/wrap.h: Unconditionally use static_assert + * inst/include/Rcpp/sugar/functions/sapply.h: Use std::result_of + (with C++11 or C++14) or std::invoke_result (C++17 or later) + * inst/include/Rcpp/sugar/functions/table.h: Use std::map + * inst/include/Rcpp/sugar/sets.h: Use std::unordered_{set,map} + * man/evalCpp.Rd: Update example + * src/api.cpp: Simplify rcpp_capabilities assignment + +2025-03-13 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/Environment.h: Switch from R_lsInternal to + R_lsInternal3 as the former is now outlawed + +2025-03-10 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-03-08 Dirk Eddelbuettel + + * inst/include/Rcpp/Function.h: Use R_ClosureEnv instead of + deprecated CLOENV if under R >= 4.5.0 + +2025-03-07 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + + * src/barrier.cpp (dataptr): Replace remaining DATAPTR with + DATAPTR_RO for suitable R greater than 3.5.0 + +2025-02-11 Dirk Eddelbuettel + + * R/Rcpp.package.skeleton.R (Rcpp.package.skeleton): Support optional + argument 'github_user' to populate URL and BugReports if given + * man/Rcpp.package.skeleton.Rd: Document new optional argument + + * R/Rcpp.package.skeleton.R (Rcpp.package.skeleton): Default version + is now '0.0.1' and not '1.0' + * inst/tinytest/test_rcpp_package_skeleton.R: Adjust test accordingly + * inst/tinytest/test_expose_class.R: Idem + +2025-02-05 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-01-31 Lev Kandel + + * inst/include/Rcpp/internal/wrap.h: Add support for std::string_view + * inst/include/Rcpp/traits/r_type_traits.h: Idem + * inst/include/Rcpp/traits/wrap_type_traits.h: Idem + * inst/include/RcppCommon.h: Include + * inst/tinytest/cpp/wrap.cpp: Add unit test for wrap(std::string_view) + * inst/tinytest/test_wrap.R: Idem + +2025-01-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version and date + * inst/include/Rcpp/config.h: Idem + +2025-01-25 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-libraries.Rdm: Add mention of PACKAGE_types.h + * vignettes/rmd/Rcpp.bib: Add AsioHeaders + * inst/bib/Rcpp.bib: Idem + +2025-01-18 Ben Bolker + + * inst/NEWS.Rd: fix trivial typos in NEWS file + +2025-01-11 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.14 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + +2025-01-01 Dirk Eddelbuettel + + * inst/include/Rcpp/Benchmark/Timer.h (R_NO_REMAP): Protect include + with preceding #ifndef now that R 4.5.0 will set this too + +2024-11-25 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version to 1.0.13.6 + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * inst/tinytest/test_date.R: Minor adjustment to datetime format test + following R Dev Day change for R bug 17350 (and issue #1347 here) + +2024-11-25 Simon Guest + + * src/attributes.cpp: fix CPP source having to be writable + +2024-11-03 Marco Colombo + + * vignettes/rmd/Rcpp-FAQ.Rmd: Fixed typos + * vignettes/rmd/Rcpp-attributes.Rmd: Idem + * vignettes/rmd/Rcpp-extending.Rmd: Idem + * vignettes/rmd/Rcpp-introduction.Rmd: Idem + * vignettes/rmd/Rcpp-libraries.Rmd: Idem + * vignettes/rmd/Rcpp-modules.Rmd: Idem + * vignettes/rmd/Rcpp-package.Rmd: Idem + * vignettes/rmd/Rcpp-quickref.Rmd: Idem + * vignettes/rmd/Rcpp-sugar.Rmd: Idem + +2024-11-02 Dirk Eddelbuettel + + * tests/tinytest.R: Minor code edit, removal of two no longer + required setters for tinytest + +2024-11-01 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version to 1.0.13.5 + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2024-10-31 Kevin Ushey + + * inst/include/Rcpp/r/compat.h: Require R (>= 4.5.0) for new APIs + +2024-10-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version to 1.0.13.4 + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * .github/workflows/ci.yaml (jobs): Roll checkout action to v4 + +2024-10-26 Gábor Csárdi + + * inst/include/Rcpp/exceptions_impl.h: check for DragonFlyBSD to fix + compilation + +2024-10-07 Iñaki Ucar + + * inst/include/Rcpp/platform/compiler.h: Uncomment + HAS_VARIADIC_TEMPLATES macro definition + * src/api.cpp: Simplify checks for variadic templates + * inst/include/Rcpp/DataFrame.h: Idem + * inst/include/Rcpp/DottedPair.h: Idem + * inst/include/Rcpp/Function.h: Idem + * inst/include/Rcpp/InternalFunctionWithStdFunction.h: Idem + * inst/include/Rcpp/Language.h: Idem + * inst/include/Rcpp/Pairlist.h: Idem + * inst/include/Rcpp/grow.h: Idem + * inst/include/Rcpp/internal/call.h: Idem + * inst/include/Rcpp/module/class.h: Idem + * inst/include/Rcpp/traits/index_sequence.h: Idem + * inst/include/Rcpp/traits/named_object.h: Idem + * inst/include/Rcpp/vector/Vector.h: Idem + * inst/include/Rcpp/Module.h: Idem + add missing is_void method + * inst/tinytest/test_module.R: Add test for void functions and + methods + +2024-10-04 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version to 1.0.13.3 + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2024-09-29 Dirk Eddelbuettel + + * inst/include/Rcpp/vector/Vector.h: Remove a cast as R_xlen_t + is returned now + +2024-09-17 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2024-09-12 Iñaki Ucar + + * vignettes/.gitignore: Refinement to ignore more files under rmd/ + * vignettes/pdf/*: Rebuilt with Ghostscript 10.03.1 + * vignettes/*.pdf: Idem + +2024-08-31 Dirk Eddelbuettel + + * DESCRIPTION (Authors@R): Added + +2024-08-28 Dirk Eddelbuettel + + * R/Rcpp.package.skeleton.R: Create DESCRIPTION with Auhors@R file + * inst/tinytest/test_rcpp_package_skeleton.R: Adjust tests + +2024-08-20 Dirk Eddelbuettel + + * inst/tinytest/test_sugar.R: Skip one more NA related test on arm64 + and macOS as failure is seen at r-universe on arm64 + + * .github/workflows/macos.yaml: Add basic r-ci setup but dialed-down + to macOS only (as Linux is covered via multiple Docker setups) + +2024-08-19 Dirk Eddelbuettel + + * Contributing.md: Refreshed content + +2024-07-30 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-modules.Rmd (are): Add short two-sentence + illustration following GitHub issue #1322 + +2024-07-24 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + 2024-07-11 Dirk Eddelbuettel * DESCRIPTION (Date, Version): Release 1.0.13 @@ -16,6 +846,16 @@ * src/barrier.cpp: Avoid using {STRING/VECTOR}_PTR * inst/include/Rcpp/r/compat.h: Include compatibility defines +2024-07-05 Kevin Ushey + + * inst/include/Rcpp/Environment.h: Drop support for UserDefinedDatabase + [ merged 2024-07-22 after release of Rcpp 1.0.13 ] + + * inst/include/Rcpp/Language.h: Avoid using SET_TYPEOF + * inst/include/Rcpp/Pairlist.h: Idem + * inst/include/Rcpp/r_cast.h: Idem + [ merged 2024-07-24 after release of Rcpp 1.0.13 ] + 2024-06-22 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll micro version diff --git a/Contributing.md b/Contributing.md index 999f2e5d0..8c975175d 100644 --- a/Contributing.md +++ b/Contributing.md @@ -35,24 +35,28 @@ to the [ChangeLog](https://github.com/RcppCore/Rcpp/blob/master/ChangeLog) and [NEWS](https://github.com/RcppCore/Rcpp/blob/master/inst/NEWS.Rd) are also appreciated. -Please note that C++ code in Rcpp must adhere to the C++98 standard. C++11 (and -above) extensions are allowed, but must be appropriately guarded so that such -code still successfully compiles under the C++98 standard. +Please note that C++ code in Rcpp must adhere to the prvailing C++ standards +as selected by the current R version ("R-release") and the upcoming R version +("R-devel"). These days, _Modern C++_ is well supported provided recent +compilers are used. As of 2024, R has supported C++17 for the past two +release cycles. We tend to be a little more conservative with Rcpp and still +support C++98 / C++11 as we know some users may be confronted with ancient +compilers. ### Coding Style It would be nice if the contributed code followed existing conventions for whitespace and indentation. We mostly follow the R Core style for with four -spaces, and curlies where K&R would put them. +spaces, and curlies where K&R would put them. Our +[editorconfig](https://editorconfig.org/) [configuration +file](https://github.com/RcppCore/Rcpp/blob/master/.editorconfig) selects +reasonable defaults. ### Asking Questions -Please direct general questions to the -[Rcpp-devel](http://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel) -mailing list (preferred, note that only subscribers can post), or alternatively -post a question on -[Stack Overflow](http://stackoverflow.com/questions/tagged/rcpp) using the -`[Rcpp]` tag. +Please direct general questions to the [discussion section of the GitHub +repo](https://github.com/RcppCore/Rcpp/discussions), or post an issue at +GitHub. Are you a new user of Rcpp? You might find the [vignettes](https://cran.r-project.org/package=Rcpp) helpful in getting diff --git a/DESCRIPTION b/DESCRIPTION index 01d48eef7..e49959e89 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -1,10 +1,23 @@ Package: Rcpp Title: Seamless R and C++ Integration -Version: 1.0.13 -Date: 2024-07-11 -Author: Dirk Eddelbuettel, Romain Francois, JJ Allaire, Kevin Ushey, Qiang Kou, - Nathan Russell, Inaki Ucar, Douglas Bates and John Chambers -Maintainer: Dirk Eddelbuettel +Version: 1.1.1.9 +Date: 2026-04-13 +Authors@R: c(person("Dirk", "Eddelbuettel", role = c("aut", "cre"), email = "edd@debian.org", + comment = c(ORCID = "0000-0001-6419-907X")), + person("Romain", "Francois", role = "aut", + comment = c(ORCID = "0000-0002-2444-4226")), + person("JJ", "Allaire", role = "aut", + comment = c(ORCID = "0000-0003-0174-9868")), + person("Kevin", "Ushey", role = "aut", + comment = c(ORCID = "0000-0003-2880-7407")), + person("Qiang", "Kou", role = "aut", + comment = c(ORCID = "0000-0001-6786-5453")), + person("Nathan", "Russell", role = "aut"), + person("Iñaki", "Ucar", role = "aut", + comment = c(ORCID = "0000-0001-6403-5550")), + person("Doug", "Bates", role = "aut", + comment = c(ORCID = "0000-0001-8316-9503")), + person("John", "Chambers", role = "aut")) Description: The 'Rcpp' package provides R functions as well as C++ classes which offer a seamless integration of R and C++. Many R data types and objects can be mapped back and forth to C++ equivalents which facilitates both writing of new @@ -14,11 +27,12 @@ Description: The 'Rcpp' package provides R functions as well as C++ classes whic Francois (2011, ), the book by Eddelbuettel (2013, ) and the paper by Eddelbuettel and Balamuta (2018, ); see 'citation("Rcpp")' for details. +Depends: R (>= 3.5.0) Imports: methods, utils Suggests: tinytest, inline, rbenchmark, pkgKitten (>= 0.1.2) URL: https://www.rcpp.org, https://dirk.eddelbuettel.com/code/rcpp.html, https://github.com/RcppCore/Rcpp License: GPL (>= 2) BugReports: https://github.com/RcppCore/Rcpp/issues -MailingList: rcpp-devel@lists.r-forge.r-project.org RoxygenNote: 6.1.1 Encoding: UTF-8 +VignetteBuilder: Rcpp diff --git a/NAMESPACE b/NAMESPACE index 45a07c50f..9f6fdf377 100644 --- a/NAMESPACE +++ b/NAMESPACE @@ -16,7 +16,6 @@ exportMethods(prompt, show, .DollarNames, initialize, "formals<-") export(Module, Rcpp.package.skeleton, populate, - loadRcppModules, # deprecated since Rcpp 0.12.5 released May 2016 setRcppClass, loadRcppClass, loadModule, @@ -33,8 +32,7 @@ export(Module, cpp_object_initializer, cpp_object_dummy, Rcpp.plugin.maker, - getRcppVersion - ) + getRcppVersion) S3method(print, bytes) S3method(format, Rcpp_stack_trace) S3method(str, Rcpp_stack_trace) diff --git a/R/Attributes.R b/R/Attributes.R index 583fbac6f..9136ec65e 100644 --- a/R/Attributes.R +++ b/R/Attributes.R @@ -1,6 +1,6 @@ # Copyright (C) 2012 - 2022 JJ Allaire, Dirk Eddelbuettel and Romain Francois -# Copyright (C) 2023 - 2024 JJ Allaire, Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +# Copyright (C) 2023 - 2026 JJ Allaire, Dirk Eddelbuettel, Romain Francois and Iñaki Ucar # # This file is part of Rcpp. # @@ -55,16 +55,16 @@ sourceCpp <- function(file = "", file <- normalizePath(file, winslash = "/") # error if the file extension isn't one supported by R CMD SHLIB - if (! tools::file_ext(file) %in% c("cc", "cpp")) { # #nocov start + if (! tools::file_ext(file) %in% c("cc", "cpp")) { stop("The filename '", basename(file), "' does not have an ", "extension of .cc or .cpp so cannot be compiled.") - } # #nocov end + } # validate that there are no spaces in the path on windows - if (.Platform$OS.type == "windows") { # #nocov start - if (grepl(' ', basename(file), fixed=TRUE)) { + if (.Platform$OS.type == "windows") { + if (grepl(' ', basename(file), fixed=TRUE)) { # #nocov start stop("The filename '", basename(file), "' contains spaces. This ", - "is not permitted.") + "is not permitted.") # #nocov end } } else { if (windowsDebugDLL) { @@ -73,7 +73,7 @@ sourceCpp <- function(file = "", "non-Windows platforms.") } windowsDebugDLL <- FALSE # now we do not need to deal with OS choice below - } # #nocov end + } } # get the context (does code generation as necessary) @@ -323,9 +323,9 @@ cppFunction <- function(code, # verify that a single function was exported and return it if (length(exported$functions) == 0) - stop("No function definition found") # #nocov + stop("No function definition found") else if (length(exported$functions) > 1) - stop("More than one function definition") # #nocov + stop("More than one function definition") # #nocov else { functionName <- exported$functions[[1]] invisible(get(functionName, env)) @@ -417,7 +417,7 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { pkgdir <- normalizePath(pkgdir, winslash = "/") descFile <- file.path(pkgdir,"DESCRIPTION") if (!file.exists(descFile)) - stop("pkgdir must refer to the directory containing an R package") # #nocov + stop("pkgdir must refer to the directory containing an R package") pkgDesc <- read.dcf(descFile)[1,] pkgname = .readPkgDescField(pkgDesc, "Package") depends <- c(.readPkgDescField(pkgDesc, "Depends", character()), @@ -429,7 +429,7 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { # check the NAMESPACE file to see if dynamic registration is enabled namespaceFile <- file.path(pkgdir, "NAMESPACE") if (!file.exists(namespaceFile)) - stop("pkgdir must refer to the directory containing an R package") # #nocov + stop("pkgdir must refer to the directory containing an R package") pkgNamespace <- readLines(namespaceFile, warn = FALSE) registration <- any(grepl("^\\s*useDynLib.*\\.registration\\s*=\\s*TRUE.*$", pkgNamespace)) @@ -499,21 +499,11 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { # built-in C++98 plugin .plugins[["cpp98"]] <- function() { - if (getRversion() >= "3.4") # with recent R versions, R can decide - list(env = list(USE_CXX98 = "yes")) - else - list(env = list(PKG_CXXFLAGS ="-std=c++98")) + list(env = list(USE_CXX98 = "yes")) } # built-in C++11 plugin .plugins[["cpp11"]] <- function() { - if (getRversion() >= "3.4") # with recent R versions, R can decide - list(env = list(USE_CXX11 = "yes")) - else if (getRversion() >= "3.1") # with recent R versions, R can decide - list(env = list(USE_CXX1X = "yes")) - else if (.Platform$OS.type == "windows") - list(env = list(PKG_CXXFLAGS = "-std=c++0x")) - else # g++-4.8.1 or later - list(env = list(PKG_CXXFLAGS ="-std=c++11")) + list(env = list(USE_CXX11 = "yes")) } # built-in C++11 plugin for older g++ compiler @@ -525,10 +515,7 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { ## this is the default in g++-6.1 and later ## per https://gcc.gnu.org/projects/cxx-status.html#cxx14 .plugins[["cpp14"]] <- function() { - if (getRversion() >= "3.4") # with recent R versions, R can decide - list(env = list(USE_CXX14 = "yes")) - else - list(env = list(PKG_CXXFLAGS ="-std=c++14")) + list(env = list(USE_CXX14 = "yes")) } # built-in C++1y plugin for C++14 and C++17 standard under development @@ -538,10 +525,7 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { # built-in C++17 plugin for C++17 standard (g++-6 or later) .plugins[["cpp17"]] <- function() { - if (getRversion() >= "3.4") # with recent R versions, R can decide - list(env = list(USE_CXX17 = "yes")) - else - list(env = list(PKG_CXXFLAGS ="-std=c++17")) + list(env = list(USE_CXX17 = "yes")) } # built-in C++20 plugin for C++20 @@ -560,6 +544,13 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { list(env = list(PKG_CXXFLAGS ="-std=c++23")) } +# built-in C++26 plugin for C++26 +.plugins[["cpp26"]] <- function() { + if (getRversion() >= "4.5") # with recent R versions, R can decide + list(env = list(USE_CXX26 = "yes")) + else + list(env = list(PKG_CXXFLAGS ="-std=c++26")) +} ## built-in C++1z plugin for C++17 standard under development ## note that as of Feb 2017 this is taken to be a moving target @@ -579,10 +570,74 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { list(env = list(PKG_CXXFLAGS ="-std=c++2b")) } +.openmpPluginDefault <- function() { + list(env = list(PKG_CXXFLAGS = "-fopenmp", PKG_LIBS = "-fopenmp")) # #nocov start +} + +.openmpPluginDarwin <- function() { + + # generate a test script for compilation + script <- tempfile("openmp-detect-", fileext = ".cpp") + writeLines("", con = script) + on.exit(unlink(script, force = TRUE), add = TRUE) + + # get the C++ compiler from R + r <- file.path(R.home("bin"), "R") + output <- tryCatch( + system2(r, c("CMD", "SHLIB", "--dry-run", shQuote(script)), stdout = TRUE), + condition = identity + ) + if (inherits(output, "condition")) + return(.openmpPluginDefault()) + + # extract the compiler invocation from the shlib output + # use some heuristics here... + index <- grep("make would use", output) + compile <- output[[index + 1L]] + + # use everything up to the first include flag, which is normally + # the R headers from CPPFLAGS + idx <- regexpr(" -I", compile, fixed = TRUE) + cxx <- substring(compile, 1L, idx - 1L) + + # check the compiler version + command <- paste(cxx, "--version") + version <- tryCatch( + system(command, intern = TRUE), + condition = identity + ) + if (inherits(version, "condition")) + return(.openmpPluginDefault()) + + # if we're using Apple clang, use alternate flags + # assume libomp was installed following https://mac.r-project.org/openmp/ + if (any(grepl("Apple clang", version))) { + cxxflags <- "-Xclang -fopenmp" + libs <- "-lomp" + } + + # if we're using Homebrew clang, add in libomp include paths + else if (any(grepl("Homebrew clang", version))) { + machine <- Sys.info()[["machine"]] + prefix <- if (machine == "arm64") "/opt/homebrew" else "/usr/local" + cxxflags <- sprintf("-I%s/opt/libomp/include -fopenmp", prefix) + libs <- sprintf("-L%s/opt/libomp/lib -fopenmp", prefix) + + # otherwise, use default -fopenmp flags for other compilers (LLVM clang; gcc) + } else { + cxxflags <- "-fopenmp" + libs <- "-fopenmp" + } + + list(env = list(PKG_CXXFLAGS = cxxflags, PKG_LIBS = libs)) # #nocov end + +} + ## built-in OpenMP plugin -.plugins[["openmp"]] <- function() { - list(env = list(PKG_CXXFLAGS="-fopenmp", - PKG_LIBS="-fopenmp")) +.plugins[["openmp"]] <- if (Sys.info()[["sysname"]] == "Darwin") { + .openmpPluginDarwin +} else { + .openmpPluginDefault } .plugins[["unwindProtect"]] <- function() { # nocov start @@ -1232,41 +1287,39 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { declarations = character() call_entries = character() - # if we are running R 3.4 or higher we can use an internal utility function + # we are running R 3.4 or higher so we can use an internal utility function # to automatically discover additional native routines that require registration - if (getRversion() >= "3.4") { - - # determine the package directory - pkgdir <- dirname(dirname(targetFile)) - - # get the generated code from R - con <- textConnection(object = NULL, open = "w") - on.exit(close(con), add = TRUE) - tools::package_native_routine_registration_skeleton( - dir = pkgdir, - con = con, - character_only = FALSE - ) - code <- textConnectionValue(con) - # look for lines containing call entries - matches <- regexec('^\\s+\\{"([^"]+)",.*$', code) - matches <- regmatches(code, matches) - matches <- Filter(x = matches, function(x) { - length(x) > 0 # #nocov start - }) - for (match in matches) { - routine <- match[[2]] - if (!routine %in% routines) { - declaration <- grep(sprintf("^extern .* %s\\(.*$", routine), code, - value = TRUE) - # FIXME: maybe we should extend this to *any* routine? - # or is there any case in which `void *` is not SEXP for a .Call? - if (routine == "run_testthat_tests") - declaration <- gsub("void *", "SEXP", declaration, fixed=TRUE) - declarations <- c(declarations, sub("^extern", "RcppExport", declaration)) - call_entries <- c(call_entries, match[[1]]) # #nocov end - } + # determine the package directory + pkgdir <- dirname(dirname(targetFile)) + + # get the generated code from R + con <- textConnection(object = NULL, open = "w") + on.exit(close(con), add = TRUE) + tools::package_native_routine_registration_skeleton( + dir = pkgdir, + con = con, + character_only = FALSE + ) + code <- textConnectionValue(con) + + # look for lines containing call entries + matches <- regexec('^\\s+\\{"([^"]+)",.*$', code) + matches <- regmatches(code, matches) + matches <- Filter(x = matches, function(x) { + length(x) > 0 # #nocov start + }) + for (match in matches) { + routine <- match[[2]] + if (!routine %in% routines) { + declaration <- grep(sprintf("^extern .* %s\\(.*$", routine), code, + value = TRUE) + # FIXME: maybe we should extend this to *any* routine? + # or is there any case in which `void *` is not SEXP for a .Call? + if (routine == "run_testthat_tests") + declaration <- gsub("void *", "SEXP", declaration, fixed=TRUE) + declarations <- c(declarations, sub("^extern", "RcppExport", declaration)) + call_entries <- c(call_entries, match[[1]]) # #nocov end } } diff --git a/R/Module.R b/R/Module.R index e0268012f..10c3cadce 100644 --- a/R/Module.R +++ b/R/Module.R @@ -1,4 +1,4 @@ -# Copyright (C) 2010 - 2021 John Chambers, Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2010 - 2026 John Chambers, Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # diff --git a/R/Rcpp.package.skeleton.R b/R/Rcpp.package.skeleton.R index e0544eb88..d8c989b50 100644 --- a/R/Rcpp.package.skeleton.R +++ b/R/Rcpp.package.skeleton.R @@ -1,4 +1,4 @@ -# Copyright (C) 2009 - 2021 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2009 - 2026 Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -24,6 +24,7 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), maintainer = if (missing(author)) "Your Name" else author, email = "your@email.com", + githubuser = NA_character_, license = "GPL (>= 2)") { havePkgKitten <- requireNamespace("pkgKitten", quietly=TRUE) @@ -81,18 +82,35 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), DESCRIPTION <- file.path(root, "DESCRIPTION") if (file.exists(DESCRIPTION)) { imports <- c(if (isTRUE(module)) "methods", sprintf("Rcpp (>= %s)", getRcppVersion())) - x <- cbind(read.dcf(DESCRIPTION), + splitname <- strsplit(author, " ")[[1]] + x <- cbind(read.dcf(DESCRIPTION, fields = c("Package", "Type", "Title", "Version", "Date", + "Description", "License")), "Imports" = paste(imports, collapse = ", "), - "LinkingTo" = "Rcpp") - x[, "Author"] <- author - x[, "Maintainer"] <- sprintf("%s <%s>", maintainer, email) + "LinkingTo" = "Rcpp", + "Authors@R" = sprintf("person(\"%s\", \"%s\", role = c(\"aut\", \"cre\"), email = \"%s\")", + paste(splitname[-length(splitname)], collapse=" "), + splitname[length(splitname)], + email)) + fields_written <- c("Package", "Type", "Title", "Version", "Date", + "Authors@R", "Description", "License", "Imports", "LinkingTo") + if (!is.na(githubuser)) { # #nocov start + x <- cbind(x, matrix("", 1, 1, dimnames=list("", "URL"))) + x[1, "URL"] <- paste0("https://github.com/", githubuser, "/", name) + x <- cbind(x, matrix("", 1, 1, dimnames=list("", "BugReports"))) + x[1, "BugReports"] <- paste0("https://github.com/", githubuser, "/", name, "/issues") + + fields_written <- c("Package", "Type", "Title", "Version", "Date", + "Authors@R", "Description", "URL", "BugReports", + "License", "Imports", "LinkingTo") + } # #nocov end + x[, "License"] <- license - x[, "Title"] <- "What the Package Does in One 'Title Case' Line" - x[, "Description"] <- "One paragraph description of what the package does as one or more full sentences." + x[, "Title"] <- "Concise Summary of What the Package Does" + x[, "Description"] <- "More about what it does (maybe more than one line)." + x[, "Version"] <- "0.0.1" message( " >> added Imports: Rcpp" ) message( " >> added LinkingTo: Rcpp" ) - write.dcf(x, file = DESCRIPTION) - + write.dcf(x[1, fields_written, drop = FALSE], file = DESCRIPTION) } ## add useDynLib and importFrom to NAMESPACE @@ -100,11 +118,7 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), lines <- readLines(NAMESPACE) ns <- file(NAMESPACE, open="w") if (!any(grepl("useDynLib", lines))) { - if (getRversion() >= "3.4.0") { - lines <- c(sprintf( "useDynLib(%s, .registration=TRUE)", name), lines) - } else { - lines <- c(sprintf( "useDynLib(%s)", name), lines) # #nocov - } + lines <- c(sprintf( "useDynLib(%s, .registration=TRUE)", name), lines) writeLines(lines, con = ns) message(" >> added useDynLib directive to NAMESPACE" ) } @@ -122,7 +136,7 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), ## update the package description help page if (havePkgKitten) { # if pkgKitten is available, use it - pkgKitten::playWithPerPackageHelpPage(name, path, maintainer, email) + pkgKitten::playWithPerPackageHelpPage(name, path, maintainer, email) # #nocov } else { .playWithPerPackageHelpPage(name, path, maintainer, email) # #nocov } @@ -184,14 +198,10 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), # generate native routines if we aren't using attributes (which already generate # them automatically) and we have at least R 3.4 if (!attributes) { - if (getRversion() >= "3.4.0") { - con <- file(file.path(src, "init.c"), "wt") - tools::package_native_routine_registration_skeleton(root, con=con) - close(con) - message(" >> created init.c for package registration") - } else { - message(" >> R version older than 3.4.0 detected, so NO file init.c created.") # #nocov - } + con <- file(file.path(src, "init.c"), "wt") + tools::package_native_routine_registration_skeleton(root, con=con) + close(con) + message(" >> created init.c for package registration") } lines <- readLines(package.doc <- file.path( root, "man", sprintf("%s-package.Rd", name))) diff --git a/R/RcppLdpath.R b/R/RcppLdpath.R index c0a37b528..d8acb323e 100644 --- a/R/RcppLdpath.R +++ b/R/RcppLdpath.R @@ -1,4 +1,4 @@ -# Copyright (C) 2010 - 2021 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -25,7 +25,7 @@ Rcpp.quoteNonStandard <- function(path) { ## On unix, check if path has only characters that do not need quoting noquote <- .Platform$OS.type == "unix" && grepl("^[[:alnum:]/._~+@%-]*$", path) ## If no quoting needed return unchanged else quote input - if (noquote) path else shQuote(path) + if (noquote) path else shQuote(path) # #nocov } ## Use R's internal knowledge of path settings to find the lib/ directory @@ -33,6 +33,7 @@ Rcpp.quoteNonStandard <- function(path) { RcppLdPath <- function() { #.Deprecated(msg=paste("This function is now deprecated as it has not", # "been needed since 2013.")) + message("'RcppLdPath' has not been needed since 2013 (!!) and may get removed in 2027. Please update your 'Makevars'.") "" } @@ -47,6 +48,7 @@ RcppLdPath <- function() { RcppLdFlags <- function() { #.Deprecated(msg=paste("This function is now deprecated as it has not", # "been needed since 2013.")) + message("'RcppLdFlags' has not been needed since 2013 (!!) and may get removed in 2027. Please update your 'Makevars'.") "" } @@ -64,14 +66,16 @@ RcppCxxFlags <- function(cxx0x=FALSE) { ## Shorter names, and call cat() directly ## CxxFlags defaults to no using c++0x extensions are these are considered non-portable -CxxFlags <- function(cxx0x=FALSE) { +CxxFlags <- function(cxx0x=FALSE) { # #nocov start #.Deprecated(msg=paste("This function is now deprecated as R uses minimally", # "viable compilers om all platforme.")) - cat(RcppCxxFlags(cxx0x=cxx0x)) # #nocov + message("'CxxFlags' has not been needed since 2013 (!!) and may get removed in 2027. Please update your 'Makevars'.") + cat(RcppCxxFlags(cxx0x=cxx0x)) # #nocov end } ## LdFlags defaults to static linking on the non-Linux platforms Windows and OS X LdFlags <- function() { + message("'LdFlags' has not been needed since 2013 (!!) and may get removed in 2027. Please update your 'Makevars'.") cat(RcppLdFlags()) } @@ -80,14 +84,16 @@ RcppCapabilities <- capabilities <- function() .Call( rcpp_capabilities ) # compile, load and call the cxx0x.c script to identify whether # the compiler is GCC >= 4.3 -RcppCxx0xFlags <- function() { +RcppCxx0xFlags <- function() { # #nocov start #.Deprecated(msg=paste("This function is now deprecated as R uses minimally", # "viable compilers om all platforme.")) - script <- Rcpp.system.file( "discovery", "cxx0x.R" ) # #nocov start + message("'RcppCxx0xFlags' has not been needed since 2013 (!!) and may get removed in 2027. Please update your 'Makevars'.") + script <- Rcpp.system.file( "discovery", "cxx0x.R" ) flag <- capture.output( source( script ) ) flag } Cxx0xFlags <- function() { + message("'Cxx0xFlags' has not been needed since 2013 (!!) and may get removed in 2027. Please update your 'Makevars'.") cat(RcppCxx0xFlags()) # #nocov end } diff --git a/R/asis.R b/R/asis.R new file mode 100644 index 000000000..5fede4fc5 --- /dev/null +++ b/R/asis.R @@ -0,0 +1,56 @@ +## These two functions are borrowed with grateful appreciation from the R.rsp package +## by Henrik Bengtsson licensed under LGPL (>= 2.1) and somewhat simplified / shortened +## feature-reduced here. Please see the R.rsp for a full-featured version and documentation + +##' Simple \sQuote{asis} Vignette Processor +##' +##' To pass pre-made pdf vignettes through \dQuote{as is}, a simple vignette +##' process is added. It is derived from the more feature-complete one in the \pkg{R.rsp} +##' package. To use it, add files named like the pdf file plus an appended \code{.asis} +##' with the vignette metainformation and register the vignette processor, see the examples. +##' +##' @title Process pdf vignettes \sQuote{asis} +##' @name asisWeave +##' @param file character Filename to be processed +##' @param ... dots Currently ignored +##' @param pattern character A regular expression describing the filename pattern +##' @return The respective filename is returned, invisibly +##' @author Henrik Bengtsson for the original versions in package \pkg{R.rsp}, +##' Dirk Eddelbuettel for the shortened ones used here +##' @examples +##' # To register this vignette engine in another package, add +##' # \code{VignetteBuilder: Rcpp} as well as \code{Suggests: Rcpp} to \code{DESCRIPTION} +##' # which uses the registration this package provides via +##' \dontrun{tools::vignetteEngine("asis", package = pkgname, pattern = "[.](pdf|html)[.]asis$", +##' weave = asisWeave, tangle = asisTangle)} +##' +##' # Use a .asis file as in the Rcpp package, for example Rcpp-FAQ.pdf.asis has these lines: +##' # %\VignetteIndexEntry{Rcpp-FAQ} +##' # %\VignetteKeywords{Rcpp, FAQ, R, Cpp} +##' # %\VignettePackage{Rcpp} +##' # %\VignetteEncoding{UTF-8} +##' # %\VignetteEngine{Rcpp::asis} +asisWeave <- function (file, ...) { # #nocov start + output <- tools::file_path_sans_ext(basename(file)) + if (!file.exists(output)) { + outputS <- file.path("..", "inst", "doc", output) + if (file.exists(outputS)) { + file.copy(outputS, output, overwrite = TRUE) + output <- outputS + } else { + stop("No file to process", call. = FALSE) + } + } + Sys.setFileTime(output, time = Sys.time()) + invisible(output) +} + +##' @rdname asisWeave +asisTangle <- function (file, ..., pattern = "(|[.][^.]*)[.]asis$") { + workdir <- "." + filename <- basename(file) + fullname <- gsub(pattern, "", filename) + filenameR <- sprintf("%s.R", fullname) + cat(sprintf("### This is an R script tangled from '%s'\n", filename), file = filenameR) + invisible(filenameR) +} # #nocov end diff --git a/R/compilerCheck.R b/R/compilerCheck.R deleted file mode 100644 index 25a67d5cf..000000000 --- a/R/compilerCheck.R +++ /dev/null @@ -1,36 +0,0 @@ -##' Helper function to establish minimal compiler versions, currently limited -##' only to \code{g++} which (particularly for older RHEL/CentOS releases) is -##' too far behind current C++11 standards required for some packages. -##' -##' This function looks up \code{g++} (as well as optional values in the -##' \code{CXX} and \code{CXX1X} environment variables) in the \code{PATH}. For -##' all values found, the output of \code{g++ -v} is analyzed for the version -##' string, which is then compared to the given minimal version. -##' @title Check for Minimal (g++) Compiler Version -##' @param minVersion An object of type \code{package_version}, with a default -##' of version 4.6.0 -##' @return A boolean value is returned, indicating if the minimal version is -##' being met -##' @author Dirk Eddelbuettel -compilerCheck <- function(minVersion=package_version("4.6.0")) { # nocov start - - binaries <- c("g++", Sys.getenv("CXX", unset=""), Sys.getenv("CXX1X", unset="")) - binpaths <- lapply(binaries, function(b) { if (b=="") NULL else Sys.which(b) }) - - allgood <- FALSE - rl <- lapply(binpaths, function(b) { - if (is.null(b)) return(NULL) - con <- pipe(paste(b, "-v 2>&1"), "r") # NB: not --version, but -v - lines <- readLines(con) - close(con) - lines <- lines[grepl("^g.. version", lines)] - if (length(lines) == 0) return(NULL) - ver <- strsplit(lines, " ")[[1]][3] # format is 'gcc version x.y.z ....' - package_version(ver) >= minVersion - }) - all(do.call(c, rl)) # drops NULLs -} # nocov end - -## TODO: maybe not limit to gcc/g++ -## TODO: maybe be smarter about combination of path, CXX and CXX1X ? -## TODO: maybe make env.var optional arguments too diff --git a/R/inline.R b/R/inline.R index 8243e033f..165c615ed 100644 --- a/R/inline.R +++ b/R/inline.R @@ -1,4 +1,4 @@ -# Copyright (C) 2009 - 2017 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2009 - 2026 Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -38,12 +38,11 @@ Rcpp.plugin.maker <- function(include.before = "", #endif using namespace Rcpp;", include.before, include.after) - out <- list(env = list( PKG_LIBS = libs ), includes = includes, LinkingTo = LinkingTo , body = function( x ) { - sprintf( "BEGIN_RCPP\n%s\nEND_RCPP", x ) + sprintf( "BEGIN_RCPP\n%s\nEND_RCPP", x ) # #nocov }, Depends = Depends, Imports = Imports) @@ -54,4 +53,3 @@ using namespace Rcpp;", include.before, include.after) } inlineCxxPlugin <- Rcpp.plugin.maker() - diff --git a/R/loadModule.R b/R/loadModule.R index 77ac55139..82d2dcda1 100644 --- a/R/loadModule.R +++ b/R/loadModule.R @@ -1,4 +1,4 @@ -# Copyright (C) 2010 - 2015 John Chambers, Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2010 - 2026 John Chambers, Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -54,12 +54,12 @@ loadModule <- function( module, what = character(), loadNow, if(exists(metaName, envir = env, inherits = FALSE)) loadM <- get(metaName, envir = env) } - else if(is(module, "Module")) { - loadM <- as.environment(module) # #nocov - module <- get(loadM, "moduleName") # #nocov + else if(is(module, "Module")) { # #nocov start + loadM <- as.environment(module) + module <- get(loadM, "moduleName") } else - stop(gettextf("Argument \"module\" should be a module or the name of a module: got an object of class \"%s\"", class(module))) + stop(gettextf("Argument \"module\" should be a module or the name of a module: got an object of class \"%s\"", class(module))) # #nocov end if(missing(loadNow)) { # test it if(is.null(loadM)) loadM <- tryCatch(Module( module, mustStart = TRUE, where = env ), @@ -104,7 +104,7 @@ loadModule <- function( module, what = character(), loadNow, assignAs <- .moduleNames(what) for( i in seq_along(what) ) { if(.botched) - assign(assignAs[[i]], NULL, envir = storage) + assign(assignAs[[i]], NULL, envir = storage) # #nocov else assign(assignAs[[i]], get(what[[i]], envir = storage), envir = env) } @@ -120,4 +120,3 @@ loadModule <- function( module, what = character(), loadNow, invisible(myCall) # #nocov } } - diff --git a/R/loadRcppModules.R b/R/loadRcppModules.R deleted file mode 100644 index 844da8fc8..000000000 --- a/R/loadRcppModules.R +++ /dev/null @@ -1,59 +0,0 @@ -# Copyright (C) 2010 - 2016 John Chambers, 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 . - -loadRcppModules <- function(direct=TRUE) { # #nocov start - # deprecation added May 2016, 'loadModule' has been prefered for years - .Deprecated("loadModule") - - ## hunt for the namespace of the package that calls this - calls <- sys.calls() - w <- which( sapply( calls, function(call){ - identical( call[[1L]], as.name( "runHook" ) ) - } ) ) - if( !length(w) ) - stop( "loadRcppModules can only be used within a .onLoad function" ) - w <- w[ length(w) ] - call <- calls[[w]] - if( !identical( call[[2L]], ".onLoad" ) ) - stop( "loadRcppModules can only be used within a .onLoad function" ) - f <- sys.frame( w ) - ns <- get("env", f ) - if( !isNamespace( ns ) ) - stop( "loadRcppModules not called from a namespace" ) - pkg <- get( "pkgname", f ) - lib <- get( "libname", f ) - - ## look for declared modules in the DESCRIPTION fields - description <- packageDescription(pkg, lib.loc=lib) - modules <- description[["RcppModules"]] - if( !is.null( modules ) ){ - modules <- strsplit( modules, "[[:space:]]*,[[:space:]]*")[[1L]] - for( m in modules ){ - tryCatch( { - mod <- Module( m, pkg, mustStart = TRUE) - if(isTRUE(direct)){ - populate( mod, ns ) - } else { - forceAssignInNamespace( m, mod, ns ) - } - assign(.moduleMetaName(m), mod, envir = ns) - }, error = function(e){ - stop( sprintf( "failed to load module %s from package %s\n%s", m, pkg, conditionMessage(e) ) ) - }) - } - } -} # #nocov end diff --git a/R/zzz.R b/R/zzz.R index 2ed6bfd79..6dd34beff 100644 --- a/R/zzz.R +++ b/R/zzz.R @@ -1,4 +1,4 @@ -# Copyright (C) 2009 - 2016 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2009 - 2025 Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -20,7 +20,8 @@ .classes_map <- new.env() .onLoad <- function(libname, pkgname){ - new_dummyObject(.dummyInstancePointer) # nocov -} - + new_dummyObject(.dummyInstancePointer) # nocov start + tools::vignetteEngine("asis", package = pkgname, pattern = "[.](pdf|html)[.]asis$", + weave = asisWeave, tangle = asisTangle) # nocov end +} diff --git a/README.md b/README.md index dfc3be5b3..bb42b2f21 100644 --- a/README.md +++ b/README.md @@ -13,9 +13,9 @@ [![CRAN use](https://jangorecki.gitlab.io/rdeps/Rcpp/CRAN_usage.svg?sanitize=true)](https://cran.r-project.org/package=Rcpp) [![CRAN indirect](https://jangorecki.gitlab.io/rdeps/Rcpp/indirect_usage.svg?sanitize=true)](https://cran.r-project.org/package=Rcpp) [![BioConductor use](https://jangorecki.gitlab.io/rdeps/Rcpp/BioC_usage.svg?sanitize=true)](https://cran.r-project.org/package=Rcpp) -[![JSS](https://img.shields.io/badge/JSS-10.18637%2Fjss.v040.i08-brightgreen)](https://dx.doi.org/10.18637/jss.v040.i08) -[![Springer useR!](https://img.shields.io/badge/Springer%20useR!-10.1007%2F978--1--4614--6868--4-brightgreen)](https://www.amazon.com/gp/product/1461468671/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1461468671&linkCode=as2&tag=rcpp-20&linkId=3P5LNUWOAQ2YMEJ6) -[![TAS](https://img.shields.io/badge/TAS-10.1080%2F00031305.2017.1375990-brightgreen)](https://dx.doi.org/10.1080/00031305.2017.1375990) +[![JSS](https://img.shields.io/badge/JSS-10.18637%2Fjss.v040.i08-brightgreen)](https://doi.org/10.18637/jss.v040.i08) +[![Springer useR!](https://img.shields.io/badge/Springer%20useR!-10.1007%2F978--1--4614--6868--4-brightgreen)](https://link.springer.com/book/10.1007/978-1-4614-6868-4) +[![TAS](https://img.shields.io/badge/TAS-10.1080%2F00031305.2017.1375990-brightgreen)](https://doi.org/10.1080/00031305.2017.1375990) ### Synopsis @@ -37,7 +37,7 @@ provides a good entry point to Rcpp as do the [Rcpp website](https://www.rcpp.org), the [Rcpp page](https://dirk.eddelbuettel.com/code/rcpp.html) and the [Rcpp Gallery](https://gallery.rcpp.org). Full documentation is provided by the -[Rcpp book](https://www.amazon.com/gp/product/1461468671/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1461468671&linkCode=as2&tag=rcpp-20&linkId=3P5LNUWOAQ2YMEJ6). +[Rcpp book](https://link.springer.com/book/10.1007/978-1-4614-6868-4). Other highlights: @@ -78,7 +78,7 @@ Among the other vignettes are the [Rcpp FAQ](https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-FAQ.pdf) and the introduction to [Rcpp Attributes](https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-attributes.pdf). -Additional documentation is available via the [Rcpp book](https://www.amazon.com/gp/product/1461468671/ref=as_li_tl?ie=UTF8&camp=1789&creative=9325&creativeASIN=1461468671&linkCode=as2&tag=rcpp-20&linkId=3P5LNUWOAQ2YMEJ6) +Additional documentation is available via the [Rcpp book](https://link.springer.com/book/10.1007/978-1-4614-6868-4) by Eddelbuettel (2013, Springer); see 'citation("Rcpp")' for details. ### Performance @@ -109,14 +109,14 @@ been factored out of Rcpp into the package RcppClassic, and it is still available for code relying on the older interface. New development should always use this Rcpp package instead. -Other usage examples are provided by packages using Rcpp. As of early January -2024, there are 2791 [CRAN](https://cran.r-project.org) packages using Rcpp -(corresponding to 13.8% of all packages, and 59.9% of packages containing -compiled code), a further 254 [BioConductor](https://www.bioconductor.org) +Other usage examples are provided by packages using Rcpp. As of early July +2025, there are 3043 [CRAN](https://cran.r-project.org) packages using Rcpp +(corresponding to 13.6% of all packages, and 61.3% of packages containing +compiled code), a further 271 [BioConductor](https://www.bioconductor.org) packages in its current release as well as an unknown number of GitHub, Bitbucket, R-Forge, ... repositories using Rcpp. All these packages provide usage examples for Rcpp. The package is in widespread use and has been -downloaded over 78.1 million times (per the partial logs from the cloud mirrors +downloaded over 100.6 million times (per the partial logs from the cloud mirrors of CRAN). ### Installation @@ -134,20 +134,20 @@ install.packages("Rcpp") #### Release Candidates -For the last several releases, we also made interim _candidate_ releases available -on the [Rcpp Drat Repo](https://RcppCore.github.io/drat/). Versions from a -[drat](https://github.com/eddelbuettel/drat) repo can be installed either by -just temporarily setting the [drat](https://github.com/eddelbuettel/drat) repo as in +We generally make interim _candidate_ releases available via the [r-universe +page](https://rcppcore.r-universe.dev/Rcpp). It provides a standard R repository which +corresponds to the current main branch in the source repository. Both binary and source +versions can be installed via ```R -install.packages("Rcpp", repos="https://RcppCore.github.io/drat") +install.packages("Rcpp", repos = c("https://rcppcore.r-universe.dev", + "https://cloud.r-project.org")) ``` -or by setting a [drat](https://github.com/eddelbuettel/drat) repo more permanently -(as described in the documentation of the [drat](https://github.com/eddelbuettel/drat) -package). +where other repos can be set as needed. -Testing the release candidates prior to actual release help. Please run this if you can. +Testing the release candidates prior to the actual release helps. Please run +this if you can. #### Source @@ -166,11 +166,9 @@ we cannot test on outdated versions of R or your OS. ### Support -The best place for questions is the -[Rcpp-devel](https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel) -mailing list hosted at R-forge. Note that in order to keep spam down, you must -be a subscriber in order to post. One can also consult the list archives to see -if your question has been asked before. +The best place for questions is the [discussion section of the GitHub +repo](https://github.com/RcppCore/Rcpp/discussions) as the previously used mailing list at R-forge +is no longer operational. The [issue tickets at the GitHub repo](https://github.com/RcppCore/Rcpp/issues) are the primary bug reporting interface. As with the other web resources, diff --git a/cleanup b/cleanup index 9bbece184..e334f7c5c 100755 --- a/cleanup +++ b/cleanup @@ -30,7 +30,9 @@ rm -f confdefs.h config.log config.status \ vignettes/*.toc vignettes/*.tpt vignettes/*.xwm rm -rf autom4te.cache inst/lib/ inst/doc/man/ inst/doc/html/ inst/doc/latex/ \ - inst/doc/auto inst/bib/auto inst/doc/Rcpp-*/auto/ src-* vignettes/auto + inst/doc/auto inst/bib/auto inst/doc/Rcpp-*/auto/ src-* vignettes/auto \ + inst/tinytest/testRcppAttributePackage/inst \ + inst/tinytest/testRcppAttributePackage/R find . -name \*~ -exec rm {} \; find . -name \*.flc -exec rm {} \; diff --git a/docker/ci-4.4/Dockerfile b/docker/ci-4.4/Dockerfile new file mode 100644 index 000000000..dd50e1f7d --- /dev/null +++ b/docker/ci-4.4/Dockerfile @@ -0,0 +1,17 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:4.4.3 + +LABEL org.label-schema.license="GPL-2.0" \ + org.label-schema.vcs-url="https://github.com/RcppCore/Rcpp" \ + maintainer="Dirk Eddelbuettel " + +RUN apt-get update \ + && apt-get install -y --no-install-recommends git \ + && install.r inline pkgKitten rbenchmark tinytest + +ENV _R_CHECK_FORCE_SUGGESTS_=FALSE +ENV _R_CHECK_TESTS_NLINES_=0 +ENV RunAllRcppTests=yes + +CMD ["bash"] diff --git a/inst/NEWS.Rd b/inst/NEWS.Rd index bae7c5063..83e557f3f 100644 --- a/inst/NEWS.Rd +++ b/inst/NEWS.Rd @@ -3,6 +3,234 @@ \newcommand{\ghpr}{\href{https://github.com/RcppCore/Rcpp/pull/#1}{##1}} \newcommand{\ghit}{\href{https://github.com/RcppCore/Rcpp/issues/#1}{##1}} +\section{Changes in Rcpp release version 1.1.1.9 (2026-04-13)}{ + \itemize{ + \item Interim release candidate for Rcpp 1.1.2 expected July 2026 + \item Changes in Rcpp API: + \itemize{ + \item Use of \code{execinfo.h} is again conditional to avoid build + complexity (Dirk in \ghpr{1445} addressing \ghit{1442}) + \item An internal state component for \code{Datetime} is now \code{int} + (Dirk in \ghpr{1448} and \ghpr{1449} fixing \ghpr{1447}) + \item Three new (in R 4.6.0) attribute accessors are used conditionally + (Dirk in \ghpr{1450} closing \ghit{1432}) + \item An UBSAN error in the Sugar-based NA comparison has been + corrected (Iñaki in \ghpr{1453} fixing \ghit{1452}) + \item Treatment of Inf outside of integer range in Sugar function has + been corrected (Iñaki in \ghpr{1458} fixing \ghit{1455}) + \item Integer overflow protection has been added for sugar functions + (Iñaki in \ghpr{1457} fixing \ghpr{1454}) + \item The parent environment is now accessed via \code{R_ParentEnv} + (Dirk in \ghpr{1460} fixing \ghit{1459}) + \item Change to returning \code{dataptr} again for better handling of + empty vectors (Iñaki in \ghpr{1462} fixing \ghit{1461}) + \item Undefined behavior errors in use of \code{ListOf} proxies have + been addressed (Iñaki in \ghpr{1464} fixing \ghit{1463}) + \item Under newer R version, \code{R_UnboundValue} is no longer used + (Iñaki in \ghpr{1466} fixing \ghit{1465}) + \item New R API access point \code{R_getRegisteredNamespace()} is used + with current R versions (Dirk in \ghpr{1469} fixing \ghit{1468}) + \item The \code{Nullable::as()} exporter now uses an explicit cast to + the templated type (Dirk in \ghpr{1471} fixing \ghit{1470}) + } + \item Changes in Rcpp Documentation: + \itemize{ + \item Reference in the bibliography used by the package vignettes have + been updated. + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Excute permissions are set consistently on scripts with shebangs + (Mattias Ellert in \ghpr{1467}) + } + \item Non-release Changes: + \itemize{ + \item A non-release hotfix 1.1.1-1 used by CRAN accommodates breaking + changes to the API in R 4.6.0. It would be nice to have the same level + of release management in R itself that CRAN expects from us. + } + } +} + +\section{Changes in Rcpp release version 1.1.1 (2026-01-08)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item An unused old R function for a compiler version check has been + removed after checking no known package uses it (Dirk in \ghpr{1395}) + \item A narrowing warning is avoided via a cast (Dirk in \ghpr{1398}) + \item Demangling checks have been simplified (Iñaki in \ghpr{1401} + addressing \ghit{1400}) + \item The treatment of signed zeros is now improved in the Sugar code + (Iñaki in \ghpr{1404}) + \item Preparations for phasing out use of \code{Rf_error} have been + made (Iñaki in \ghpr{1407}) + \item The long-deprecated function \code{loadRcppModules()} has been + removed (Dirk in \ghpr{1416} closing \ghit{1415}) + \item Some non-API includes from R were refactored to accommodate + R-devel changes (Iñaki in \ghpr{1418} addressing \ghit{1417}) + \item An accessor to \code{Rf_rnbeta} has been removed (Dirk in + \ghpr{1419} also addressing \ghit{1420}) + \item Code accessing non-API \code{Rf_findVarInFrame} now uses + \code{R_getVarEx} (Dirk in \ghpr{1423} fixing \ghit{1421}) + \item Code conditional on the R version now expects at least R 3.5.0; + older code has been removed (Dirk in \ghpr{1426} fixing \ghit{1425}) + \item The non-API \code{ATTRIB} entry point to the R API is no longer + used (Dirk in \ghpr{1430} addressing \ghit{1429}) + \item The unwind-protect mechanism is now used unconditionally (Dirk + in \ghpr{1437} closing \ghit{1436}) + } + \item Changes in Rcpp Attributes: + \itemize{ + \item The OpenMP plugin has been generalized for different macOS + compiler installations (Kevin in \ghpr{1414}) + } + \item Changes in Rcpp Documentation: + \itemize{ + \item Vignettes are now processed via a new "asis" processor adopted + from \pkg{R.rsp} (Dirk in \ghpr{1394} fixing \ghit{1393}) + \item R is now cited via its DOI (Dirk) + \item A (very) stale help page has been removed (Dirk in \ghpr{1428} + fixing \ghit{1427}) + \item The main README.md was updated emphasizing r-universe in favor of + the local drat repos (Dirk in \ghpr{1431}) + } + \item Changes in Rcpp Deployment: + \itemize{ + \item A temporary change in R-devel concerning NA part in complex variables + was accommodated, and then reverted (Dirk in \ghpr{1399} fixing \ghit{1397}) + \item The macOS CI runners now use macos-14 (Dirk in \ghpr{1405}) + \item A message is shown if \code{R.h} is included before Rcpp headers + as this can lead to errors (Dirk in \ghpr{1411} closing \ghit{1410}) + \item Old helper functions use \code{message()} to signal they are not used, + deprecation and removal to follow (Dirk in \ghpr{1413} closing + \ghit{1412}) + \item Three tests were being silenced following \ghpr{1413} (Dirk in + \ghpr{1422}) + \item The heuristic whether to run all available tests was refined + (Dirk in \ghpr{1434} addressing \ghit{1433}) + \item Coverage has been tweaked via additional \code{#nocov} tags (Dirk + in \ghpr{1435}) + } + \item Non-release Changes: + \itemize{ + \item Two interim non-releases 1.1.0.8.1 and .2 were made in order to + unblock CRAN due to changes in R-devel rather than Rcpp + } + } +} + +\section{Changes in Rcpp release version 1.1.0 (2025-07-01)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item C++11 is now the required minimal C++ standard + \item The \code{std::string_view} type is now covered by \code{wrap()} + (Lev Kandel in \ghpr{1356} as discussed in \ghit{1357}) + \item A last remaining \code{DATAPTR} use has been converted to + \code{DATAPTR_RO} (Dirk in \ghpr{1359}) + \item Under R 4.5.0 or later, \code{R_ClosureEnv} is used instead of + \code{CLOENV} (Dirk in \ghpr{1361} fixing \ghpr{1360}) + \item Use of \code{lsInternal} switched to \code{lsInternal3} (Dirk in + #1362) + \item Removed compiler detection macro in a header cleanup setting + C++11 as the minunum (Dirk in \ghpr{1364} closing \ghit{1363}) + \item Variadic templates are now used onconditionally given C++11 (Dirk + in \ghpr{1367} closing \ghit{1366}) + \item Remove \code{RCPP_USING_CXX11} as a \code{#define} as C++11 is + now a given (Dirk in \ghpr{1369}) + \item Additional cleanup for \code{__cplusplus} checks (Iñaki in + \ghpr{1371} fixing \ghit{1370}) + \item Unordered set construction no longer needs a macro for the + pre-C++11 case (Iñaki in \ghpr{1372}) + \item Lambdas are supported in a Rcpp Sugar functions (Iñaki in \ghpr{1373}) + \item The Date(time)Vector classes now have default ctor (Dirk in + \ghpr{1385} closing \ghpr{1384}) + \item Fixed an issue where Rcpp::Language would duplicate its arguments + (Kevin in \ghpr{1388}, fixing \ghit{1386}) + } + \item Changes in Rcpp Attributes: + \itemize{ + \item The C++26 standard now has plugin support (Dirk in \ghpr{1381} + closing \ghit{1380}) + } + \item Changes in Rcpp Documentation: + \itemize{ + \item Several typos were correct in the NEWS file (Ben Bolker in + \ghpr{1354}) + \item The Rcpp Libraries vignette mentions \code{PACKAGE_types.h} to + declare types used in \code{RcppExports.cpp} (Dirk in \ghpr{1355}) + \item The vignettes bibliography file was updated to current package + versions, and now uses doi references (Dirk in \ghpr{1389}) + } + \item Changes in Rcpp Deployment: + \itemize{ + \item \code{Rcpp.package.skeleton()} creates \sQuote{URL} and + \sQuote{BugReports} if given a GitHub username (Dirk in \ghpr{1358}) + \item R 4.4.* has been added to the CI matrix (Dirk in \ghpr{1376}) + \item Tests involving NA propagation are skipped under linux-arm64 as + they are under macos-arm (Dirk in \ghpr{1379} closing \ghit{1378}) + } + } +} + +\section{Changes in Rcpp release version 1.0.14 (2025-01-11)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Support for user-defined databases has been removed (Kevin in + \ghpr{1314} fixing \ghit{1313}) + \item The \code{SET_TYPEOF} function and macro is no longer used (Kevin + in \ghpr{1315} fixing \ghit{1312}) + \item An erroneous cast to \code{int} affecting large return object + has been removed (Dirk in \ghpr{1335} fixing \ghpr{1334}) + \item Compilation on DragonFlyBSD is now supported (Gábor Csárdi in + \ghpr{1338}) + \item Use read-only \code{VECTOR_PTR} and \code{STRING_PTR} only + with R 4.5.0 or later (Kevin in \ghpr{1342} fixing \ghit{1341}) + } + \item Changes in Rcpp Attributes: + \itemize{ + \item The \code{sourceCpp()} function can now handle input files with + read-only modes (Simon Guest in \ghpr{1346} fixing \ghit{1345}) + } + \item Changes in Rcpp Deployment: + \itemize{ + \item One unit tests for arm64 macOS has been adjusted; a macOS + continuous integration runner was added (Dirk in \ghpr{1324}) + \item Authors@R is now used in DESCRIPTION as mandated by CRAN, the + \code{Rcpp.package.skeleton()} function also creates it (Dirk in + \ghpr{1325} and \ghpr{1327}) + \item A single datetime format test has been adjusted to match a change + in R-devel (Dirk in \ghpr{1348} fixing \ghit{1347}) + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The Rcpp Modules vignette was extended slightly following + \ghit{1322} (Dirk) + \item Pdf vignettes have been regenerated under Ghostscript 10.03.1 to + avoid a false positive by a Windows virus scanner (Iñaki in + \ghpr{1331}) + \item A (large) number of (old) typos have been corrected in the + vignettes (Marco Colombo in \ghpr{1344}) + } + } +} + +\section{Changes in Rcpp 'hot-fix' release version 1.0.13-1 (2024-11-01)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Use read-only \code{VECTOR_PTR} and \code{STRING_PTR} only with + with R 4.5.0 or later (Kevin in \ghpr{1342} fixing \ghit{1341}) + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Authors@R is now used in DESCRIPTION as mandated by CRAN + } + } +} + \section{Changes in Rcpp release version 1.0.13 (2024-07-11)}{ \itemize{ \item Changes in Rcpp API: @@ -35,7 +263,7 @@ added in two places (Michael Chirico in \ghpr{1272} closing \ghit{1271}). \item Casts to avoid integer overflow in matrix row/col selections - have neem added (Aaron Lun \ghpr{1281}). + have been added (Aaron Lun \ghpr{1281}). \item Three print format correction uncovered by R-devel were applied with thanks to Tomas Kalibera (Dirk in \ghpr{1285}). \item Correct a print format correction in the RcppExports glue code diff --git a/inst/bib/Rcpp.bib b/inst/bib/Rcpp.bib index 1aac8921c..568522d4a 100644 --- a/inst/bib/Rcpp.bib +++ b/inst/bib/Rcpp.bib @@ -3,13 +3,14 @@ @String{manuals @String{RCoreTeam = "{R Core Team}" } @String{RFoundation = "R Foundation for Statistical Computing" } @String{R-Forge = "https://R-Forge.R-Project.org/" } +@String{DOI = "10.32614/CRAN.package." } @manual{Abrahams+Grosse-Kunstleve:2003:Boost.Python, author = { David Abrahams and Ralf W. Grosse-Kunstleve }, organization = "Boost Consulting", title = "Building Hybrid Systems with Boost.Python", year = 2003, - url = "https://www.boostpro.com/writing/bpl.pdf" + url = "https://www.boost.org/doc/libs/latest/libs/python/doc/html/article.html" } @Book{Abrahams+Gurtovoy:2004:TemplateMetaprogramming, @@ -59,7 +60,7 @@ @InProceedings{Bates+DebRoy:2001:C++Classes Universit\"at Wien, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch}, year = {2001}, - url = {https://www.ci.tuwien.ac.at/Conferences/DSC-2001/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2001/Proceedings/}, note = {ISSN 1609-395X} } @@ -75,59 +76,75 @@ @Misc{Brokken:2011:Cpp @Manual{CRAN:anytime, title = {anytime: Anything to 'POSIXct' or 'Date' Converter}, author = {Dirk Eddelbuettel}, - year = {2020}, - note = {R package version 0.3.9}, - url = CRAN # "package=anytime" + year = {2025}, + note = {R package version 0.3.12}, + oldurl = CRAN # "package=anytime", + doi = DOI # "anytime" +} + +@Manual{CRAN:AsioHeaders, + title = {'Asio' C++ Header Files}, + author = {Dirk Eddelbuettel}, + year = {2025}, + note = {R package version 1.30.2-1}, + oldurl = CRAN # "package=AsioHeaders", + doi = DOI # "AsioHeaders" } @Manual{CRAN:BH, title = {BH: Boost C++ Header Files}, author = {Dirk Eddelbuettel and John W. Emerson and Michael J. Kane}, - year = {2023}, - note = {R package version 1.81.0-1}, - url = CRAN # "package=BH" + year = {2025}, + note = {R package version 1.90.0-1}, + oldurl = CRAN # "package=BH", + doi = DOI # "BH" } @Manual{CRAN:Matrix, title = {\pkg{Matrix}: Sparse and Dense Matrix Classes and Methods}, author = {Douglas Bates and Martin Maechler}, - year = 2023, - note = {R package version 1.6-4}, - url = CRAN # "package=Matrix" + year = 2026, + note = {R package version 1.7-5}, + oldurl = CRAN # "package=Matrix", + doi = DOI # "Matrix" } @Manual{CRAN:RInside, title = {RInside: C++ classes to embed R in C++ applications}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2020, - note = {R package version 0.2.16}, - url = CRAN # "package=RInside" + year = 2025, + note = {R package version 0.2.19}, + oldurl = CRAN # "package=RInside", + doi = DOI # "RInside" } @Manual{CRAN:RProtoBuf, title = {RProtoBuf: R Interface to the Protocol Buffers API}, author = {Romain Fran\c{c}ois and Dirk Eddelbuettel and Murray Stokely and Jeroen Ooms}, - year = 2023, - note = {R package version 0.4.21}, - url = CRAN # "package=RProtoBuf" + year = 2025, + note = {R package version 0.4.24}, + oldurl = CRAN # "package=RProtoBuf", + doi = DOI # "RProtoBuf" } @Manual{CRAN:RQuantLib, - title = {RQuantLib: {R} interface to the {QuantLib} library}, + title = {RQuantLib: {R} Interface to the {QuantLib} Library}, author = {Dirk Eddelbuettel and Khanh Nguyen and Terry Leitch}, - year = 2023, - note = {R package version 0.4.20}, - url = CRAN # "package=RQuantLib" + year = 2025, + note = {R package version 0.4.26}, + oldurl = CRAN # "package=RQuantLib", + doi = DOI # "RQuantLib" } @Manual{CRAN:RUnit, title = {RUnit: R Unit Test Framework}, author = {Matthias Burger and Klaus Juenemann and Thomas Koenig}, - year = 2018, - note = {R package version 0.4.32}, - url = CRAN # "package=RUnit" + year = 2024, + note = {R package version 0.4.33.1}, + oldurl = CRAN # "package=RUnit", + doi = DOI # "RUnit" } @Manual{CRAN:Rcpp, @@ -135,9 +152,10 @@ @Manual{CRAN:Rcpp author = {Dirk Eddelbuettel and Romain Fran\c{c}ois and JJ Allaire and Kevin Ushey and Qiang Kou and Nathan Russel and John Chambers and Douglas Bates}, - year = 2024, - note = {R package version 1.0.13}, - url = CRAN # "package=Rcpp" + year = 2026, + note = {R package version 1.1.1}, + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Attributes, @@ -145,72 +163,80 @@ @Manual{CRAN:Rcpp:Attributes author = {J. J. Allaire and Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {{Rcpp} Attributes}, - year = 2023, + year = 2026, note = {Vignette included in R package Rcpp}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:FAQ, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Frequently Asked Questions About {Rcpp}}, - year = 2023, + year = 2026, note = {Vignette included in R package {Rcpp}}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Libraries, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel}, title = {Thirteen Simple Steps for Creating An R Package with an External C++ Library }, - year = 2023, + year = 2026, note = {Vignette included in R package Rcpp}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Modules, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Exposing {C++} functions and classes with {Rcpp} modules}, - year = 2023, + year = 2026, note = {Vignette included in R package Rcpp}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Package, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Writing a package that uses {Rcpp}}, - year = 2023, + year = 2026, note = {Vignette included in R package {Rcpp}}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Sugar, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Rcpp syntactic sugar}, - year = 2023, + year = 2026, note = {Vignette included in R package {Rcpp}}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:RcppArmadillo, - title = {RcppArmadillo: Rcpp integration for Armadillo - templated linear algebra library}, + title = {RcppArmadillo: Rcpp Integration for the Armadillo + Templated Linear Algebra Library}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois and Douglas Bates and Binxiang Ni and Conrad Sanderson}, - year = 2023, - note = {R package version 0.12.6.6.1}, - url = CRAN # "package=RcppArmadillo" + year = 2025, + note = {R package version 15.2.3-1}, + oldurl = CRAN # "package=RcppArmadillo", + doi = DOI # "RcppArmadillo" } @Manual{CRAN:RcppCCTZ, title = {RcppCCTZ: Rcpp Bindings for the CCTZ Library}, author = {Dirk Eddelbuettel}, - year = 2022, - note = {R package version 0.2.12}, - url = CRAN # "package=RcppCCTZ" + year = 2024, + note = {R package version 0.2.13}, + oldurl = CRAN # "package=RcppCCTZ", + doi = DOI # "RcppCCTZ" } @Manual{CRAN:RcppClassic, @@ -218,73 +244,82 @@ @Manual{CRAN:RcppClassic author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, year = 2022, note = {R package version 0.9.13}, - url = CRAN # "package=RcppClassic" + oldurl = CRAN # "package=RcppClassic", + doi = DOI # "RcppClassic" } @Manual{CRAN:RcppDate, title = {RcppDate: 'date' C++ Header Libary for Date and Time Functionality}, author = {Dirk Eddelbuettel}, - year = 2021, - note = {R package version 0.0.3}, - url = CRAN # "package=RcppDate" + year = 2025, + note = {R package version 0.0.6}, + oldurl = CRAN # "package=RcppDate", + doi = DOI # "RcppDate" } @Manual{CRAN:RcppDE, - title = {RcppDE: Global optimization by differential evolution in C++}, + title = {RcppDE: Global Optimization by Differential Evolution in C++}, author = {Dirk Eddelbuettel}, - year = 2022, - note = {R package version 0.1.7}, - url = CRAN # "package=RcppDE" + year = 2026, + note = {R package version 0.1.9}, + oldurl = CRAN # "package=RcppDE", + doi = DOI # "RcppDE" } @Manual{CRAN:RcppEigen, - title = {RcppEigen: Rcpp integration for the Eigen templated linear - algebra library}, + title = {RcppEigen: Rcpp Integration for the Eigen Templated Linear + Algebra Library}, author = {Douglas Bates and Dirk Eddelbuettel and Romain Fran\c{c}ois and Yixuan Qiu}, - year = 2023, - note = {{R} package version 0.3.3.9.4}, - url = CRAN # "package=RcppEigen" + year = 2024, + note = {{R} package version 0.3.4.0.2}, + oldurl = CRAN # "package=RcppEigen", + doi = DOI # "RcppEigen" } @Manual{CRAN:RcppExamples, title = {RcppExamples: Examples using {Rcpp} to interface {R} and {C++}}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2019, - note = {R package version 0.1.9}, - url = CRAN # "package=RcppExamples" + year = 2025, + note = {R package version 0.1.10}, + oldurl = CRAN # "package=RcppExamples", + doi = DOI # "RcppExamples" } @Manual{CRAN:RcppGSL, - title = {RcppGSL: Rcpp integration for GNU GSL vectors and matrices}, + title = {RcppGSL: Rcpp Integration for GNU GSL Vectors and Matrices}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2021, - note = {R package version 0.3.10}, - url = CRAN # "package=RcppGSL" + year = 2026, + note = {R package version 0.3.14}, + oldurl = CRAN # "package=RcppGSL", + doi = DOI # "RcppGSL" } @Manual{CRAN:RcppInt64, title = {RppInt64: Rcpp-Based Helper Functions to Pass Int64 and nanotime Values Between R and C++}, author = {Dirk Eddelbuettel}, - year = 2023, - note = {R package version 0.0.4}, - url = CRAN # "package=RcppInt64" + year = 2024, + note = {R package version 0.0.5}, + oldurl = CRAN # "package=RcppInt64", + doi = DOI # "RcppInt64" } @Manual{CRAN:RcppZiggurat, title = {RcppZiggurat: Rcpp Integration of Different Ziggurat Normal RNG Implementations}, author = {Dirk Eddelbuettel}, - year = 2020, - note = {R package version 0.1.6}, - url = CRAN # "package=RcppZiggurat" + year = 2025, + note = {R package version 0.1.8}, + oldurl = CRAN # "package=RcppZiggurat", + doi = DOI # "RcppZiggurat" } @Manual{CRAN:Rserve, - title = {Rserve: Binary R server}, + title = {Rserve: Versatile R Server}, author = {Simon Urbanek}, - year = 2023, - note = {R package version 1.8-13}, - url = CRAN # "package=Rserve" + year = 2025, + note = {R package version 1.8-16}, + oldurl = CRAN # "package=Rserve", + doi = DOI # "Rserve" } @Manual{CRAN:cxxPack, @@ -293,78 +328,87 @@ @Manual{CRAN:cxxPack author = {Dominick Samperi}, year = 2010, note = {R package version 7.0.6}, - url = CRAN # "package=cxxPack" + oldurl = CRAN # "package=cxxPack", + doi = DOI # "cxxPack" } @Manual{CRAN:devtools, title = {devtools: Tools to Make Developing R Packages Easier}, author = {Hadley Wickham and Jim Hester and Winston Chang}, - year = 2022, - note = {R package version 2.4.5}, - url = CRAN # "package=devtools" + year = 2025, + note = {R package version 2.4.6}, + oldurl = CRAN # "package=devtools", + doi = DOI # "devtools" } @Manual{CRAN:highlight, - title = {highlight: Syntax highlighter}, + title = {highlight: Syntax Highlighter}, author = {Hadley Wickham and Romain Fran\c{c}ois and Andre Simon}, - year = 2023, - note = {R package with version 0.5.1}, - url = CRAN # "package=highlight" + year = 2025, + note = {R package with version 0.5.2}, + oldurl = CRAN # "package=highlight", + doi = DOI # "highlight" } @Manual{CRAN:inline, - title = {inline: Inline C, C++, Fortran function calls from + title = {inline: Functions to Inline C, C++, Fortran Function Calls from R}, author = {Oleg Sklyar and Duncan Murdoch and Mike Smith and Dirk Eddelbuettel and Romain Fran\c{c}ois and Karline Soetaert and Johannes Ranke}, - year = 2021, - note = {R package version 0.3.19}, - url = CRAN # "package=inline" + year = 2025, + note = {R package version 0.3.21}, + oldurl = CRAN # "package=inline", + doi = DOI # "inline" } @Manual{CRAN:littler, title = {littler: {R} at the {Command-Line} via r}, author = {Dirk Eddelbuettel and Jeffrey Horner}, - year = 2023, - note = {R package version 0.3.19}, - url = CRAN # "package=littler" + year = 2025, + note = {R package version 0.3.21}, + oldurl = CRAN # "package=littler", + doi = DOI # "littler" } @Manual{CRAN:microbenchmark, title = {microbenchmark: Accurate Timing Functions}, author = {Olaf Mersmann}, year = 2023, - note = {R package version 1.4-10}, - url = CRAN # "package=microbenchmark" + note = {R package version 1.5-0}, + oldurl = CRAN # "package=microbenchmark", + doi = DOI # "microbenchmark" } @Manual{CRAN:minqa, - title = {minqa: Derivative-free optimization algorithms by - quadratic approximation}, + title = {minqa: Derivative-Free Optimization Algorithms by + Quadratic Approximation}, author = {Douglas Bates and Katharine M. Mullen and John C. Nash and Ravi Varadhan}, - year = 2023, - note = {R package version 1.2.6}, - url = CRAN # "package=minqa" + year = 2024, + note = {R package version 1.2.8}, + oldurl = CRAN # "package=minqa", + doi = DOI # "minqa" } @Manual{CRAN:pkgKitten, title = {pkgKitten: Create Simple Packages Which Do not Upset R Package Checks}, author = {Dirk Eddelbuettel}, - year = {2023}, - note = {R package version 0.2.3}, - url = CRAN # "package=pkgKitten" + year = {2024}, + note = {R package version 0.2.4}, + oldurl = CRAN # "package=pkgKitten", + doi = DOI # "pkgKitten" } @Manual{CRAN:profvis, title = {profvis: Interactive Visualizations for Profiling R Code}, author = {Winston Chang and Javier Luraschi and and Timothy Mastny}, - year = 2023, - note = {R package version 0.3.8}, - url = CRAN # "package=profvis" + year = 2024, + note = {R package version 0.4.0}, + oldurl = CRAN # "package=profvis", + doi = DOI # "profvis" } @Manual{CRAN:rbenchmark, @@ -372,15 +416,17 @@ @Manual{CRAN:rbenchmark author = {Wacek Kusnierczyk}, year = 2012, note = {R package version 1.0.0}, - url = CRAN # "package=rbenchmark" + oldurl = CRAN # "package=rbenchmark", + doi = DOI # "rbenchmark" } @Manual{CRAN:roxygen2, - title = {roxygen2: In-source documentation for R}, + title = {roxygen2: In-Line documentation for R}, author = {Hadley Wickham and Peter Danenberg and G\a'bor Cs\a'rdi and Manuel Eugster}, - year = 2022, - note = {R package version 7.2.3}, - url = CRAN # "package=roxygen2" + year = 2025, + note = {R package version 7.3.3}, + oldurl = CRAN # "package=roxygen2", + doi = DOI # "roxygen2" } @Article{CRAN:testthat, @@ -489,7 +535,8 @@ @Book{Eddelbuettel:2013:Rcpp series = {Use R!}, year = 2013, address = {New York}, - isbn = {978-1-4614-6867-7} + isbn = {978-1-4614-6867-7}, + doi = {10.1007/978-1-4614-6868-4} } @article{Efron:1979:Bootstrap, @@ -508,7 +555,7 @@ @MISC{Eigen:Web author = {Ga\"{e}l Guennebaud and Beno\^{i}t Jacob and others}, title = {Eigen v3}, year = 2012, - url = {https://eigen.tuxfamily.org} + url = {https://libeigen.gitlib.io/} } @Manual{GSL, @@ -727,8 +774,8 @@ @Article{PeerJ:Rcpp issue = {e3188v1}, year = 2017, month = {August}, - url = {https://doi.org/10.7287/peerj.preprints.3188v1/}, - doi = {10.7287/peerj.preprints.3188v1/} + url = {https://peerj.com/preprints/3188v1/}, + doi = {10.7287/peerj.preprints.3188v1} } @Book{Plauger+Et+Al:2000:STL, @@ -744,16 +791,17 @@ @manual{QuantLib author = {{QuantLib Core Team}}, year = 2021, title = {QuantLib: a free/open-source library for quantitative finance}, - url = {https://quantlib.org} + url = {https://www.quantlib.org} } @manual{R:Administration, author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "R Installation and Administration", annote = {{ISBN} 3-900051-09-7}, + doi = "10.32614/R.manuals", url = manuals # "R-admin.html" } @@ -761,9 +809,10 @@ @manual{R:Extensions author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "Writing R extensions", annote = {{ISBN} 3-900051-11-9}, + doi = "10.32614/R.manuals", url = manuals # "R-exts.html" } @@ -771,9 +820,10 @@ @manual{R:Internals author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "R internals", annote = {{ISBN} 3-900051-14-3}, + doi = "10.32614/R.manuals", url = manuals # "R-ints.html" } @@ -781,9 +831,10 @@ @manual{R:Language author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "R language", annote = {{ISBN} 3-900051-13-5}, + doi = "10.32614/R.manuals", url = manuals # "R-lang.html" } @@ -793,7 +844,8 @@ @Manual{R:Main author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, + doi = "10.32614/R.manuals", url = {https://www.R-project.org/} } @@ -835,7 +887,7 @@ @TechReport{Sanderson:2010:Armadillo Experiments }, institution = {{NICTA}}, year = 2010, - url = "https://arma.sf.net" + url = "https://arma.sourceforge.net" } @Book{Stroustrup:1997:Cpp, @@ -901,7 +953,7 @@ @InProceedings{Urbanek:2003:Rserve Statistical Computing, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch and Achim Zeileis}, year = {2003}, - url = {https://www.ci.tuwien.ac.at/Conferences/DSC-2003/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2003/Proceedings/}, note = {{ISSN 1609-395X}} } @@ -945,7 +997,7 @@ @Book{Venables+Ripley:2002:MASS address = {New York}, year = 2002, note = {ISBN 0-387-95457-0}, - url = {https://www.stats.ox.ac.uk/pub/MASS4}, + url = {https://www.stats.ox.ac.uk/pub/MASS4/}, } @misc{arxiv:corels, @@ -954,7 +1006,7 @@ @misc{arxiv:corels author = {Elaine Angelino and Nicholas Larus-Stone and Daniel Alabi and Margo Seltzer and Cynthia Rudin}, year = 2017, - howpublished = {\href{https://www.arxiv.org/1704.01701}{arXiv:1704.01701}}, + howpublished = {\href{https://arxiv.org/abs/1704.01701}{arXiv:1704.01701}}, archivePrefix ={arXiv}, primaryClass = {stat.ML} } @@ -962,7 +1014,7 @@ @misc{arxiv:corels @Misc{github:corels, author = {Nicholas Laurus-Stone}, title = {corels: {Learning Certifiably Optimal Rule Lists}}, - howpublished = {\url{https://github.com/nlarusstone/corels}. Also online at \url{https://corels.eecs.harvard.edu/corels/}}, + howpublished = {\url{https://github.com/corels/corels}. Also online at \url{https://corels.cs.ubc.ca/corels/Larus-Stone_thesis.pdf}}, month = 06, year = 2019 } @@ -970,7 +1022,7 @@ @Misc{github:corels @Misc{github:rcppcorels, author = {Dirk Eddelbuettel}, title = {RcppCorels: R binding for the 'Certifiably Optimal RulE ListS (Corels)' Learner}, - howpublished = {\url{https://github.com/eddelbuettel/rcppcorels}}, + howpublished = {\url{https://github.com/corels/rcppcorels}}, month = 11, year = 2019 } diff --git a/inst/discovery/cxx0x.R b/inst/discovery/cxx0x.R old mode 100644 new mode 100755 diff --git a/inst/examples/ConvolveBenchmarks/overhead.r b/inst/examples/ConvolveBenchmarks/overhead.r old mode 100644 new mode 100755 diff --git a/inst/examples/ConvolveBenchmarks/overhead.sh b/inst/examples/ConvolveBenchmarks/overhead.sh old mode 100644 new mode 100755 diff --git a/inst/examples/Misc/ifelseLooped.r b/inst/examples/Misc/ifelseLooped.r old mode 100644 new mode 100755 diff --git a/inst/examples/Misc/newFib.r b/inst/examples/Misc/newFib.r old mode 100644 new mode 100755 diff --git a/inst/examples/OpenMP/OpenMPandInline.r b/inst/examples/OpenMP/OpenMPandInline.r old mode 100644 new mode 100755 diff --git a/inst/include/Rcpp.h b/inst/include/Rcpp.h index e518a70ac..bec4f9f41 100644 --- a/inst/include/Rcpp.h +++ b/inst/include/Rcpp.h @@ -32,6 +32,7 @@ #include #include #include +#include #include #include diff --git a/inst/include/Rcpp/Benchmark/Timer.h b/inst/include/Rcpp/Benchmark/Timer.h index d8e3ea735..5dab598ac 100644 --- a/inst/include/Rcpp/Benchmark/Timer.h +++ b/inst/include/Rcpp/Benchmark/Timer.h @@ -1,8 +1,6 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// // Timer.h: Rcpp R/C++ interface class library -- Rcpp benchmark utility // -// Copyright (C) 2012 - 2014 JJ Allaire, Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2025 JJ Allaire, Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -26,7 +24,9 @@ #include #include -#define R_NO_REMAP +#ifndef R_NO_REMAP + #define R_NO_REMAP +#endif #include #if defined(_WIN32) diff --git a/inst/include/Rcpp/DataFrame.h b/inst/include/Rcpp/DataFrame.h index 0d03efcde..65a81576f 100644 --- a/inst/include/Rcpp/DataFrame.h +++ b/inst/include/Rcpp/DataFrame.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // DataFrame.h: Rcpp R/C++ interface class library -- data frames // -// Copyright (C) 2010 - 2021 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -61,29 +60,21 @@ namespace Rcpp{ } // By definition, the number of rows in a data.frame is contained - // in its row.names attribute. If it has row names of the form 1:n, - // they will be stored as {NA_INTEGER, -}. Unfortunately, - // getAttrib(df, R_RowNamesSymbol) will force an expansion of that - // compact form thereby allocating a huge vector when we just want - // the row.names. Hence this workaround. - inline int nrow() const { - SEXP rn = R_NilValue ; - SEXP att = ATTRIB( Parent::get__() ) ; - while( att != R_NilValue ){ - if( TAG(att) == R_RowNamesSymbol ) { - rn = CAR(att) ; - break ; - } - att = CDR(att) ; - } - if (Rf_isNull(rn)) - return 0; - if (TYPEOF(rn) == INTSXP && LENGTH(rn) == 2 && INTEGER(rn)[0] == NA_INTEGER) - return std::abs(INTEGER(rn)[1]); - return LENGTH(rn); + // in its row.names attribute. Since R 3.5.0 this is returned as a + // compact sequence from which we can just take the (x)length + // But as this makes an allocation an even simpler check on length as + // discussed in #1430 is also possible and preferable. We also switch + // to returning R_xlen_t which as upcast from int is safe + inline R_xlen_t nrow() const { +#if R_VERSION < R_Version(4,6,0) + Shield rn{Rf_getAttrib(Parent::get__(), R_RowNamesSymbol)}; + return Rf_xlength(rn); +#else + return R_nrow(Parent::get__()); +#endif } - template + template void push_back( const T& object){ Parent::push_back(object); set_type_after_push(); @@ -108,8 +99,8 @@ namespace Rcpp{ } // Offer multiple variants to accomodate both old interface here and signatures in other classes - inline int nrows() const { return DataFrame_Impl::nrow(); } - inline int rows() const { return DataFrame_Impl::nrow(); } + inline R_xlen_t nrows() const { return DataFrame_Impl::nrow(); } + inline R_xlen_t rows() const { return DataFrame_Impl::nrow(); } inline R_xlen_t ncol() const { return DataFrame_Impl::length(); } inline R_xlen_t cols() const { return DataFrame_Impl::length(); } @@ -117,14 +108,10 @@ namespace Rcpp{ static DataFrame_Impl create(){ return DataFrame_Impl() ; } - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - static DataFrame_Impl create(const T&... args) { - return DataFrame_Impl::from_list(Parent::create(args...)); - } - #else - #include - #endif + template + static DataFrame_Impl create(const T&... args) { + return DataFrame_Impl::from_list(Parent::create(args...)); + } private: void set__(SEXP x){ diff --git a/inst/include/Rcpp/DottedPair.h b/inst/include/Rcpp/DottedPair.h index eeb6825a8..ba08c10b0 100644 --- a/inst/include/Rcpp/DottedPair.h +++ b/inst/include/Rcpp/DottedPair.h @@ -2,7 +2,7 @@ // // DottedPair.h: Rcpp R/C++ interface class library -- dotted pair list template // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -35,14 +35,10 @@ RCPP_API_CLASS(DottedPair_Impl), DottedPair_Impl(SEXP x) { Storage::set__(x) ; } - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - DottedPair_Impl(const T&... args) { - Storage::set__(pairlist(args...)); - } - #else - #include - #endif + template + DottedPair_Impl(const T&... args) { + Storage::set__(pairlist(args...)); + } void update(SEXP){} diff --git a/inst/include/Rcpp/Environment.h b/inst/include/Rcpp/Environment.h index fdd33c330..7a77eb020 100644 --- a/inst/include/Rcpp/Environment.h +++ b/inst/include/Rcpp/Environment.h @@ -1,9 +1,9 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // Environment.h: Rcpp R/C++ interface class library -- access R environments // -// Copyright (C) 2009 - 2013 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2014 - 2020 Dirk Eddelbuettel, Romain Francois and Kevin Ushey +// Copyright (C) 2009-2013 Dirk Eddelbuettel and Romain François +// Copyright (C) 2014-2025 Dirk Eddelbuettel, Romain François and Kevin Ushey +// Copyright (C) 2026 Dirk Eddelbuettel, Romain François, Kevin Ushey and Iñaki Ucar // // This file is part of Rcpp. // @@ -84,12 +84,7 @@ namespace Rcpp{ */ SEXP ls(bool all) const { SEXP env = Storage::get__() ; - if( is_user_database() ){ - R_ObjectTable *tb = (R_ObjectTable*) R_ExternalPtrAddr(HASHTAB(env)); - return tb->objects(tb) ; - } else { - return R_lsInternal( env, all ? TRUE : FALSE ) ; - } + return R_lsInternal3(env, all ? TRUE : FALSE, TRUE); return R_NilValue ; } @@ -101,17 +96,8 @@ namespace Rcpp{ * @return a SEXP (possibly R_NilValue) */ SEXP get(const std::string& name) const { - SEXP env = Storage::get__() ; - SEXP nameSym = Rf_install(name.c_str()); - SEXP res = Rf_findVarInFrame( env, nameSym ) ; - - if( res == R_UnboundValue ) return R_NilValue ; - - /* We need to evaluate if it is a promise */ - if( TYPEOF(res) == PROMSXP){ - res = internal::Rcpp_eval_impl( res, env ) ; - } - return res ; + Symbol nameSym = Rf_install(name.c_str()); + return get(nameSym); } /** @@ -123,14 +109,14 @@ namespace Rcpp{ */ SEXP get(Symbol name) const { SEXP env = Storage::get__() ; +#if R_VERSION < R_Version(4,5,0) SEXP res = Rf_findVarInFrame( env, name ) ; - - if( res == R_UnboundValue ) return R_NilValue ; - - /* We need to evaluate if it is a promise */ - if( TYPEOF(res) == PROMSXP){ - res = internal::Rcpp_eval_impl( res, env ) ; - } + if (res == R_UnboundValue) return R_NilValue; + if (TYPEOF(res) == PROMSXP) + res = internal::Rcpp_eval_impl(res, env); +#else + SEXP res = R_getVarEx(name, env, FALSE, R_NilValue); +#endif return res ; } @@ -143,17 +129,8 @@ namespace Rcpp{ * */ SEXP find( const std::string& name) const{ - SEXP env = Storage::get__() ; - SEXP nameSym = Rf_install(name.c_str()); - SEXP res = Rf_findVar( nameSym, env ) ; - - if( res == R_UnboundValue ) throw binding_not_found(name) ; - - /* We need to evaluate if it is a promise */ - if( TYPEOF(res) == PROMSXP){ - res = internal::Rcpp_eval_impl( res, env ) ; - } - return res ; + Symbol nameSym = Rf_install(name.c_str()); + return find(nameSym); } /** @@ -164,18 +141,15 @@ namespace Rcpp{ */ SEXP find(Symbol name) const{ SEXP env = Storage::get__() ; +#if R_VERSION < R_Version(4,5,0) SEXP res = Rf_findVar( name, env ) ; - - if( res == R_UnboundValue ) { - // Pass on the const char* to the RCPP_EXCEPTION_CLASS's - // const std::string& requirement - throw binding_not_found(name.c_str()) ; - } - - /* We need to evaluate if it is a promise */ - if( TYPEOF(res) == PROMSXP){ - res = internal::Rcpp_eval_impl( res, env ) ; - } + if (res == R_UnboundValue) throw binding_not_found(name.c_str()); + if (TYPEOF(res) == PROMSXP) + res = internal::Rcpp_eval_impl(res, env); +#else + SEXP res = R_getVarEx(name, env, TRUE, NULL); + if (res == NULL) throw binding_not_found(name.c_str()); +#endif return res ; } @@ -189,8 +163,13 @@ namespace Rcpp{ */ bool exists( const std::string& name ) const { SEXP nameSym = Rf_install(name.c_str()); +#if R_VERSION < R_Version(4,5,0) SEXP res = Rf_findVarInFrame( Storage::get__() , nameSym ) ; - return res != R_UnboundValue ; + return res != R_UnboundValue; +#else + SEXP res = R_getVarEx(nameSym, Storage::get__(), FALSE, NULL); + return res != NULL; +#endif } /** @@ -318,14 +297,6 @@ namespace Rcpp{ return R_BindingIsActive(nameSym, Storage::get__()) ; } - /** - * Indicates if this is a user defined database. - */ - bool is_user_database() const { - SEXP env = Storage::get__() ; - return OBJECT(env) && Rf_inherits(env, "UserDefinedDatabase") ; - } - /** * @return the global environment. See ?globalenv */ @@ -385,7 +356,11 @@ namespace Rcpp{ * The parent environment of this environment */ Environment_Impl parent() const { +#if R_VERSION < R_Version(4,5,0) return Environment_Impl( ENCLOS(Storage::get__()) ) ; +#else + return Environment_Impl(R_ParentEnv(Storage::get__())); +#endif } /** diff --git a/inst/include/Rcpp/Function.h b/inst/include/Rcpp/Function.h index d27bcf2db..c98777bd3 100644 --- a/inst/include/Rcpp/Function.h +++ b/inst/include/Rcpp/Function.h @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // Function.h: Rcpp R/C++ interface class library -- functions (also primitives and builtins) // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain François and Iñaki Ucar // // This file is part of Rcpp. // @@ -43,12 +43,12 @@ namespace Rcpp{ case BUILTINSXP: Storage::set__(x); break; - default: + default: // #nocov start const char* fmt = "Cannot convert object to a function: " "[type=%s; target=CLOSXP, SPECIALSXP, or " "BUILTINSXP]."; throw not_compatible(fmt, Rf_type2char(TYPEOF(x))); - } + } // #nocov end } /** @@ -70,10 +70,23 @@ namespace Rcpp{ } Function_Impl(const std::string& name, const std::string& ns) { +#if R_VERSION < R_Version(4,5,0) + // before R 4.5.0 we would use Rf_findVarInFrame Shield env(Rf_findVarInFrame(R_NamespaceRegistry, Rf_install(ns.c_str()))); - if (env == R_UnboundValue) { + if (env == R_UnboundValue) stop("there is no namespace called \"%s\"", ns); - } +#elif R_VERSION < R_Version(4,6,0) || R_SVN_REVISION < 89746 + // during R 4.5.* and before final R 4.6.0 we could use R_getVarEx + // along with R_NamespaceRegistry but avoid R_UnboundValue + Shield env(R_getVarEx(Rf_install(ns.c_str()), R_NamespaceRegistry, FALSE, R_NilValue)); + if (env == R_NilValue) + stop("there is no namespace called \"%s\"", ns); +#else + // late R 4.6.0 development got us R_getRegisteredNamespace + Shield env(R_getRegisteredNamespace(ns.c_str())); + if (env == R_NilValue) + stop("there is no namespace called \"%s\"", ns); +#endif get_function(name, env); } @@ -82,14 +95,10 @@ namespace Rcpp{ return Rcpp_fast_eval(call, R_GlobalEnv); } - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - SEXP operator()(const T&... args) const { + template + SEXP operator()(const T&... args) const { return invoke(pairlist(args...), R_GlobalEnv); - } - #else - #include - #endif + } /** * Returns the environment of this function @@ -99,7 +108,11 @@ namespace Rcpp{ if( TYPEOF(fun) != CLOSXP ) { throw not_a_closure(Rf_type2char(TYPEOF(fun))); } - return CLOENV(fun) ; + #if (defined(R_VERSION) && R_VERSION >= R_Version(4,5,0)) + return R_ClosureEnv(fun); + #else + return CLOENV(fun); + #endif } /** diff --git a/inst/include/Rcpp/InternalFunction.h b/inst/include/Rcpp/InternalFunction.h index 42f97f90f..9a4ad6625 100644 --- a/inst/include/Rcpp/InternalFunction.h +++ b/inst/include/Rcpp/InternalFunction.h @@ -26,9 +26,7 @@ #include -#ifdef RCPP_USING_CXX11 #include -#endif namespace Rcpp{ @@ -37,7 +35,6 @@ namespace Rcpp{ RCPP_GENERATE_CTOR_ASSIGN(InternalFunction_Impl) -#ifdef RCPP_USING_CXX11 template InternalFunction_Impl(const std::function &fun) { set( @@ -51,9 +48,6 @@ namespace Rcpp{ InternalFunction_Impl(RESULT_TYPE (*fun)(T...)) { set(XPtr >(new CppFunctionN(fun), true)); } -#else - #include -#endif void update(SEXP){} private: diff --git a/inst/include/Rcpp/InternalFunctionWithStdFunction.h b/inst/include/Rcpp/InternalFunctionWithStdFunction.h index f003b10e2..993bf282e 100644 --- a/inst/include/Rcpp/InternalFunctionWithStdFunction.h +++ b/inst/include/Rcpp/InternalFunctionWithStdFunction.h @@ -1,9 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- // // InternalFunction_with_std_function.h: Rcpp R/C++ interface class library -- exposing C++ std::function's // -// Copyright (C) 2014 Christian Authmann -// Copyright (C) 2015 Romain Francois and Dirk Eddelbuettel +// Copyright (C) 2014 - 2025 Christian Authmann +// Copyright (C) 2015 - 2025 Romain Francois and Dirk Eddelbuettel // // This file is part of Rcpp. // @@ -23,17 +22,12 @@ #ifndef Rcpp_InternalFunctionWithStdFunction_h #define Rcpp_InternalFunctionWithStdFunction_h -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) #include -#endif #include namespace Rcpp { namespace InternalFunctionWithStdFunction { - #if !defined(HAS_VARIADIC_TEMPLATES) && !defined(RCPP_USING_CXX11) - #include - #endif template class CppFunctionBaseFromStdFunction : public CppFunctionBase { diff --git a/inst/include/Rcpp/Language.h b/inst/include/Rcpp/Language.h index a2d250a87..d893df67a 100644 --- a/inst/include/Rcpp/Language.h +++ b/inst/include/Rcpp/Language.h @@ -1,7 +1,7 @@ // Language.h: Rcpp R/C++ interface class library -- language objects (calls) // -// Copyright (C) 2010 - 2022 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -102,19 +102,15 @@ namespace Rcpp{ * 0.0 is wrapped as a numeric vector using wrap( const& double ) * ... */ - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - Language_Impl(const std::string& symbol, const T&... t) { - Storage::set__(pairlist(Rf_install(symbol.c_str()), t...) ); - } + template + Language_Impl(const std::string& symbol, const T&... t) { + Storage::set__(langlist(Rf_install(symbol.c_str()), t...) ); + } - template - Language_Impl(const Function& function, const T&... t) { - Storage::set__(pairlist(function, t...)); - } - #else - #include - #endif + template + Language_Impl(const Function& function, const T&... t) { + Storage::set__(langlist(function, t...)); + } /** * sets the symbol of the call @@ -162,8 +158,10 @@ namespace Rcpp{ return internal::Rcpp_eval_impl( Storage::get__(), env); } - void update( SEXP x){ - SET_TYPEOF( x, LANGSXP ); + void update(SEXP x) { + if (TYPEOF(x) != LANGSXP) { + Storage::set__(r_cast(x)); + } SET_TAG( x, R_NilValue ); } @@ -188,11 +186,7 @@ namespace Rcpp{ }; template -#if __cplusplus < 201103L - class unary_call : public std::unary_function { -#else class unary_call : public std::function { -#endif public: unary_call( Language call_ ) : call(call_), proxy(call_,1) {} unary_call( Language call_, R_xlen_t index ) : call(call_), proxy(call_,index){} @@ -209,11 +203,7 @@ namespace Rcpp{ }; template -#if __cplusplus < 201103L - class binary_call : public std::binary_function { -#else class binary_call : public std::function { -#endif public: binary_call( Language call_ ) : call(call_), proxy1(call_,1), proxy2(call_,2) {} binary_call( Language call_, R_xlen_t index1, R_xlen_t index2 ) : call(call_), proxy1(call_,index1), proxy2(call_,index2){} diff --git a/inst/include/Rcpp/Module.h b/inst/include/Rcpp/Module.h index cdb12d4d0..7556e9f3c 100644 --- a/inst/include/Rcpp/Module.h +++ b/inst/include/Rcpp/Module.h @@ -1,7 +1,7 @@ // Module.h: Rcpp R/C++ interface class library -- Rcpp modules // -// Copyright (C) 2010 - 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -86,7 +86,6 @@ namespace Rcpp{ #include #include -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) namespace Rcpp { template inline void signature(std::string& s, const char* name) { @@ -112,6 +111,7 @@ namespace Rcpp { } inline int nargs() { return sizeof...(T); } + inline bool is_void() { return std::is_void::value; } inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } @@ -131,11 +131,7 @@ namespace Rcpp { Rcpp::List formals; }; } -#else - #include - // templates CppFunction0, ..., CppFunction65 - #include -#endif + #include #include @@ -176,7 +172,7 @@ namespace Rcpp{ private: ParentMethod* parent_method_pointer ; } ; -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) + template inline void ctor_signature(std::string& s, const std::string& classname) { s.assign(classname); @@ -250,13 +246,6 @@ namespace Rcpp{ return nargs == n ; } -#else -#include -#include -#include -#include -#endif - typedef bool (*ValidConstructor)(SEXP*,int) ; typedef bool (*ValidMethod)(SEXP*,int) ; @@ -380,7 +369,7 @@ namespace Rcpp{ } ; -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) + template class CppMethodImplN : public CppMethod { public: @@ -428,7 +417,7 @@ namespace Rcpp{ return call(f, args); } inline int nargs() { return sizeof...(T); } - inline bool is_void() { return std::is_void::value;} + inline bool is_void() { return std::is_void::value; } inline bool is_const() { return IsConst; } inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } private: @@ -440,10 +429,8 @@ namespace Rcpp{ template using Const_Pointer_CppMethodN = Pointer_CppMethodImplN; -#else - #include - #include -#endif + + template class CppProperty { @@ -551,7 +538,7 @@ namespace Rcpp{ } ; } -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) + namespace Rcpp { template void function(const char* name_, RESULT_TYPE (*fun)(T... t), const char* docstring = 0) { @@ -569,10 +556,7 @@ namespace Rcpp { } } } -#else - // function factories - #include -#endif + namespace Rcpp { @@ -587,7 +571,7 @@ namespace Rcpp { public: typedef XPtr XP_Class ; typedef Rcpp::XPtr XP ; - CppClass( SEXP x) : S4(x){}; + CppClass( SEXP x) : S4(x){}; // #nocov CppClass( Module* p, class_Base* cl, std::string& buffer ) : S4("C++Class") { XP_Class clxp( cl, false, R_NilValue, R_NilValue ) ; diff --git a/inst/include/Rcpp/Nullable.h b/inst/include/Rcpp/Nullable.h index 53704ffb8..df0e9248b 100644 --- a/inst/include/Rcpp/Nullable.h +++ b/inst/include/Rcpp/Nullable.h @@ -81,6 +81,18 @@ namespace Rcpp { return m_sexp; } +#if R_VERSION > R_Version(4,3,0) && defined(RCPP_ENABLE_NULLABLE_T) + /** + * operator T() to return nullable object + * + * @throw 'not initialized' if object has not been set + */ + inline operator T() const { + checkIfSet(); + return Rcpp::as(m_sexp); + } +#endif + /** * get() accessor for object * @@ -126,7 +138,7 @@ namespace Rcpp { /** * Returns m_sexp as a T */ - inline T as() { return get(); } + inline T as() { return Rcpp::as(get()); } /** * Return a clone of m_sexp as a T diff --git a/inst/include/Rcpp/Pairlist.h b/inst/include/Rcpp/Pairlist.h index d06bf6f34..375d74271 100644 --- a/inst/include/Rcpp/Pairlist.h +++ b/inst/include/Rcpp/Pairlist.h @@ -2,7 +2,7 @@ // // Pairlist.h: Rcpp R/C++ interface class library -- pair lists objects (LISTSXP) // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -42,16 +42,15 @@ namespace Rcpp{ Pairlist_Impl(SEXP x){ Storage::set__(r_cast(x)) ; } - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - Pairlist_Impl(const T&... args ){ - Storage::set__(pairlist(args... )) ; + template + Pairlist_Impl(const T&... args ){ + Storage::set__(pairlist(args... )) ; + } + + void update(SEXP x) { + if (TYPEOF(x) != LISTSXP) { + Storage::set__(r_cast(x)); } - #else - #include - #endif - void update(SEXP x){ - SET_TYPEOF( x, LISTSXP ) ; } } ; diff --git a/inst/include/Rcpp/Promise.h b/inst/include/Rcpp/Promise.h index 8b4096a01..01bec2978 100644 --- a/inst/include/Rcpp/Promise.h +++ b/inst/include/Rcpp/Promise.h @@ -2,7 +2,8 @@ // // Promise.h: Rcpp R/C++ interface class library -- promises (PROMSXP) // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain François +// Copyright (C) 2026 Dirk Eddelbuettel, Romain François and Iñaki Ucar // // This file is part of Rcpp. // @@ -48,13 +49,18 @@ namespace Rcpp{ * Return the result of the PRVALUE macro on the promise */ SEXP value() const{ - SEXP val = PRVALUE( Storage::get__() ) ; - if( val == R_UnboundValue ) throw unevaluated_promise() ; - return val ; + if (!was_evaluated()) throw unevaluated_promise(); + return PRVALUE(Storage::get__()); } bool was_evaluated() const { +#if R_VERSION < R_Version(4,6,0) return PRVALUE(Storage::get__()) != R_UnboundValue ; +#else + SEXP env = environment(); + R_BindingType_t bt = R_GetBindingType(Storage::get__(), env); + return bt != R_BindingTypeUnbound; +#endif } /** diff --git a/inst/include/Rcpp/Rmath.h b/inst/include/Rcpp/Rmath.h index 757b88582..ad1958e52 100644 --- a/inst/include/Rcpp/Rmath.h +++ b/inst/include/Rcpp/Rmath.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // Rmath.h: Rcpp R/C++ interface class library -- Wrappers for R's Rmath API // -// Copyright (C) 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012-2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -131,12 +130,10 @@ namespace R { inline double qnbinom(double p, double sz, double pb, int lt, int lg) { return ::Rf_qnbinom(p, sz, pb, lt, lg); } inline double rnbinom(double sz, double pb) { return ::Rf_rnbinom(sz, pb); } -#if R_VERSION >= R_Version(3, 1, 2) inline double dnbinom_mu(double x, double sz, double mu, int lg) { return ::Rf_dnbinom_mu(x, sz, mu, lg); } inline double pnbinom_mu(double x, double sz, double mu, int lt, int lg) { return ::Rf_pnbinom_mu(x, sz, mu, lt, lg); } inline double qnbinom_mu(double x, double sz, double mu, int lt, int lg) { return ::Rf_qnbinom_mu(x, sz, mu, lt, lg); } //inline double rnbinom_mu(double sz, double mu) { return ::Rf_rnbinom_mu(sz, mu); } -#endif /* Poisson Distribution */ inline double dpois(double x, double lb, int lg) { return ::Rf_dpois(x, lb, lg); } @@ -160,7 +157,7 @@ namespace R { inline double dnbeta(double x, double a, double b, double ncp, int lg) { return ::Rf_dnbeta(x, a, b, ncp, lg); } inline double pnbeta(double x, double a, double b, double ncp, int lt, int lg) { return ::Rf_pnbeta(x, a, b, ncp, lt, lg); } inline double qnbeta(double p, double a, double b, double ncp, int lt, int lg) { return ::Rf_qnbeta(p, a, b, ncp, lt, lg); } - inline double rnbeta(double a, double b, double np) { return ::Rf_rnbeta(a, b, np); } + //inline double rnbeta(double a, double b, double np) { return ::Rf_rnbeta(a, b, np); } /* Non-central F Distribution */ inline double dnf(double x, double df1, double df2, double ncp, int lg) { return ::Rf_dnf(x, df1, df2, ncp, lg); } diff --git a/inst/include/Rcpp/S4.h b/inst/include/Rcpp/S4.h index d5fa8746a..2ec8cdebf 100644 --- a/inst/include/Rcpp/S4.h +++ b/inst/include/Rcpp/S4.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // S4.h: Rcpp R/C++ interface class library -- S4 objects // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -38,10 +37,10 @@ namespace Rcpp{ * * @param x must be an S4 object */ - S4_Impl(SEXP x) { + S4_Impl(SEXP x) { // #nocov start if( ! ::Rf_isS4(x) ) throw not_s4() ; Storage::set__(x) ; - } + } // #nocov end S4_Impl& operator=( SEXP other ){ Storage::set__( other ) ; @@ -57,7 +56,7 @@ namespace Rcpp{ S4_Impl( const std::string& klass ){ Shield x( R_do_new_object(R_do_MAKE_CLASS(klass.c_str())) ); if (!Rf_inherits(x, klass.c_str())) - throw S4_creation_error( klass ) ; + throw S4_creation_error( klass ) ; // #nocov Storage::set__(x) ; } diff --git a/inst/include/Rcpp/String.h b/inst/include/Rcpp/String.h index 8316acee1..2103e5b28 100644 --- a/inst/include/Rcpp/String.h +++ b/inst/include/Rcpp/String.h @@ -2,7 +2,7 @@ // String.h: Rcpp R/C++ interface class library -- single string // // Copyright (C) 2012 - 2020 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2021 - 2023 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +// Copyright (C) 2021 - 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -117,7 +117,7 @@ namespace Rcpp { String(const std::string& s, cetype_t enc = CE_UTF8) : data(R_NilValue), token(R_NilValue), buffer(s), valid(false), buffer_ready(true), enc(enc) { RCPP_STRING_DEBUG("String(const std::string&, cetype_t)"); } -#ifdef RCPP_USING_CXX11 + /** move constructor */ String(String&& s) : data(s.data), token(s.token), buffer(std::move(s.buffer)), valid(s.valid), buffer_ready(s.buffer_ready), enc(s.enc) { // Erase s. @@ -134,7 +134,7 @@ namespace Rcpp { String(std::string&& s, cetype_t enc = CE_UTF8) : data(R_NilValue), token(R_NilValue), buffer(s), valid(false), buffer_ready(true), enc(enc) { RCPP_STRING_DEBUG("String(std::string&&, cetype_t)"); } -#endif + String(const std::wstring& s, cetype_t enc = CE_UTF8) : data(internal::make_charsexp(s)), token(R_NilValue), valid(true), buffer_ready(false), enc(enc) { token = Rcpp_PreciousPreserve(data); RCPP_STRING_DEBUG("String(const std::wstring&, cetype_t)"); @@ -267,7 +267,6 @@ namespace Rcpp { buffer_ready = true; return *this; } -#ifdef RCPP_USING_CXX11 inline String& operator=(String&& other) { data = other.data; token = other.token; @@ -290,7 +289,6 @@ namespace Rcpp { buffer_ready = true; return *this; } -#endif inline String& operator=(const char* s) { buffer = s; valid = false; @@ -734,24 +732,14 @@ namespace Rcpp { } // Rcpp -/** hash can be in std or std::tr1 */ -#if defined(RCPP_USING_CXX11) || defined(HAS_TR1) -namespace std -{ -#ifndef RCPP_USING_CXX11 -namespace tr1 { -#endif +/** hash via std */ +namespace std { template <> - struct hash - { + struct hash { size_t operator()(const Rcpp::String & s) const{ return hash()(s.get_cstring()); } }; -#ifndef RCPP_USING_CXX11 -} -#endif } -#endif #endif diff --git a/inst/include/Rcpp/StringTransformer.h b/inst/include/Rcpp/StringTransformer.h index 0824c031c..8c009ff04 100644 --- a/inst/include/Rcpp/StringTransformer.h +++ b/inst/include/Rcpp/StringTransformer.h @@ -1,7 +1,7 @@ // clone.h: Rcpp R/C++ interface class library -- clone RObject's // -// Copyright (C) 2010 - 2022 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -26,11 +26,7 @@ namespace Rcpp{ template -#if __cplusplus < 201103L - class StringTransformer : public std::unary_function { -#else class StringTransformer : public std::function { -#endif public: StringTransformer( const UnaryOperator& op_ ): op(op_), buffer(){} ~StringTransformer(){} diff --git a/inst/include/Rcpp/Symbol.h b/inst/include/Rcpp/Symbol.h index 7a4152c62..beabc546c 100644 --- a/inst/include/Rcpp/Symbol.h +++ b/inst/include/Rcpp/Symbol.h @@ -43,21 +43,13 @@ namespace Rcpp{ Storage::set__( x ) ; break; /* nothing to do */ case CHARSXP: { - #if R_VERSION >= R_Version(3,2,0) SEXP charSym = Rf_installChar(x); // R 3.2.0 or later have Rf_installChar - #else - SEXP charSym = Rf_install(CHAR(x)); // cannot be gc()'ed once in symbol table - #endif Storage::set__( charSym ) ; break ; } case STRSXP: { /* FIXME: check that there is at least one element */ - #if R_VERSION >= R_Version(3,2,0) SEXP charSym = Rf_installChar(STRING_ELT(x, 0 )); // R 3.2.0 or later have Rf_installChar - #else - SEXP charSym = Rf_install( CHAR(STRING_ELT(x, 0 )) ); // cannot be gc()'ed once in symbol table - #endif Storage::set__( charSym ); break ; } diff --git a/inst/include/Rcpp/algorithm.h b/inst/include/Rcpp/algorithm.h index 1080dec12..2c84815cd 100644 --- a/inst/include/Rcpp/algorithm.h +++ b/inst/include/Rcpp/algorithm.h @@ -2,7 +2,8 @@ // // algorithm.h: Rcpp R/C++ interface class library -- data frames // -// Copyright (C) 2016 - 2017 Daniel C. Dillon +// Copyright (C) 2016 - 2024 Daniel C. Dillon +// Copyright (C) 2025 Daniel C. Dillon and Iñaki Ucar // // This file is part of Rcpp. // @@ -22,14 +23,6 @@ #ifndef Rcpp__Algorithm_h #define Rcpp__Algorithm_h -#if __cplusplus >= 201103L || __INTEL_CXX11_MODE__ == 1 -# define RCPP_CONSTEXPR_FUNC constexpr -# define RCPP_CONSTEXPR_VAR constexpr -#else -# define RCPP_CONSTEXPR_FUNC -# define RCPP_CONSTEXPR_VAR const -#endif - namespace Rcpp { namespace algorithm { @@ -38,9 +31,7 @@ namespace helpers { typedef struct {char a[2];} CTYPE_SHORT; typedef struct {char a[3];} CTYPE_INT; typedef struct {char a[4];} CTYPE_LONG; -#ifdef RCPP_HAS_LONG_LONG_TYPES typedef struct {char a[5];} CTYPE_LONG_LONG; -#endif typedef struct {char a[6];} CTYPE_FLOAT; typedef struct {char a[7];} CTYPE_DOUBLE; typedef struct {char a[8];} CTYPE_LONG_DOUBLE; @@ -49,9 +40,7 @@ namespace helpers { typedef struct {char a[11];} CTYPE_UNSIGNED_SHORT; typedef struct {char a[12];} CTYPE_UNSIGNED_INT; typedef struct {char a[13];} CTYPE_UNSIGNED_LONG; -#ifdef RCPP_HAS_LONG_LONG_TYPES typedef struct {char a[14];} CTYPE_UNSIGNED_LONG_LONG; -#endif typedef struct {char a[128];} CTYPE_UNKNOWN; template< std::size_t I > @@ -69,10 +58,8 @@ namespace helpers { template<> struct ctype_helper< sizeof(CTYPE_LONG) > { typedef long type; static const bool value = true; }; -#ifdef RCPP_HAS_LONG_LONG_TYPES template<> struct ctype_helper< sizeof(CTYPE_LONG_LONG) > { typedef rcpp_long_long_type type; static const bool value = true; }; -#endif template<> struct ctype_helper< sizeof(CTYPE_FLOAT) > { typedef float type; static const bool value = true; }; @@ -98,11 +85,8 @@ namespace helpers { template<> struct ctype_helper< sizeof(CTYPE_UNSIGNED_LONG) > { typedef unsigned long type; static const bool value = true; }; -#ifdef RCPP_HAS_LONG_LONG_TYPES template<> struct ctype_helper< sizeof(CTYPE_UNSIGNED_LONG_LONG) > { typedef rcpp_ulong_long_type type; static const bool value = true; }; -#endif - template< typename T > struct ctype @@ -111,9 +95,7 @@ namespace helpers { static CTYPE_SHORT test(const short &); static CTYPE_INT test(const int &); static CTYPE_LONG test(const long &); -#ifdef RCPP_HAS_LONG_LONG_TYPES static CTYPE_LONG_LONG test(const rcpp_long_long_type &); -#endif static CTYPE_FLOAT test(const float &); static CTYPE_DOUBLE test(const double &); static CTYPE_LONG_DOUBLE test(const long double &); @@ -122,9 +104,7 @@ namespace helpers { static CTYPE_UNSIGNED_SHORT test(const unsigned short &); static CTYPE_UNSIGNED_INT test(const unsigned int &); static CTYPE_UNSIGNED_LONG test(const unsigned long &); -#ifdef RCPP_HAS_LONG_LONG_TYPES static CTYPE_UNSIGNED_LONG_LONG test(const rcpp_ulong_long_type &); -#endif static CTYPE_UNKNOWN test(...); static T make(); @@ -139,9 +119,7 @@ namespace helpers { static CTYPE_SHORT test(const short &); static CTYPE_INT test(const int &); static CTYPE_LONG test(const long &); -#ifdef RCPP_HAS_LONG_LONG_TYPES static CTYPE_LONG_LONG test(const rcpp_long_long_type &); -#endif static CTYPE_FLOAT test(const float &); static CTYPE_DOUBLE test(const double &); static CTYPE_LONG_DOUBLE test(const long double &); @@ -150,9 +128,7 @@ namespace helpers { static CTYPE_UNSIGNED_SHORT test(const unsigned short &); static CTYPE_UNSIGNED_INT test(const unsigned int &); static CTYPE_UNSIGNED_LONG test(const unsigned long &); -#ifdef RCPP_HAS_LONG_LONG_TYPES static CTYPE_UNSIGNED_LONG_LONG test(const rcpp_ulong_long_type &); -#endif static CTYPE_UNKNOWN test(...); static T make(); @@ -167,29 +143,29 @@ namespace helpers { template<> struct rtype_helper< double > { typedef double type; - static RCPP_CONSTEXPR_VAR int RTYPE = REALSXP; + static constexpr int RTYPE = REALSXP; static inline double NA() { return NA_REAL; } - static inline RCPP_CONSTEXPR_FUNC double ZERO() { return 0.0; } - static inline RCPP_CONSTEXPR_FUNC double ONE() { return 1.0; } + static inline constexpr double ZERO() { return 0.0; } + static inline constexpr double ONE() { return 1.0; } }; template<> struct rtype_helper< int > { typedef int type; - static RCPP_CONSTEXPR_VAR int RTYPE = INTSXP; + static constexpr int RTYPE = INTSXP; static inline int NA() { return NA_INTEGER; } - static inline RCPP_CONSTEXPR_FUNC int ZERO() { return 0; } - static inline RCPP_CONSTEXPR_FUNC int ONE() { return 1; } + static inline constexpr int ZERO() { return 0; } + static inline constexpr int ONE() { return 1; } }; template< typename T > struct rtype { typedef typename rtype_helper< typename ctype< T >::type >::type type; typedef rtype_helper< typename ctype< T >::type > helper_type; - static RCPP_CONSTEXPR_VAR int RTYPE = helper_type::RTYPE; + static constexpr int RTYPE = helper_type::RTYPE; static inline T NA() { return helper_type::NA(); } - static inline RCPP_CONSTEXPR_FUNC T ZERO() { return helper_type::ZERO(); } - static inline RCPP_CONSTEXPR_FUNC T ONE() { return helper_type::ONE(); } + static inline constexpr T ZERO() { return helper_type::ZERO(); } + static inline constexpr T ONE() { return helper_type::ONE(); } }; struct log { @@ -483,7 +459,4 @@ void sqrt(InputIterator begin, InputIterator end, OutputIterator out) { } // namespace algorithm } // namespace Rcpp -#undef RCPP_CONSTEXPR_FUNC -#undef RCPP_CONSTEXPR_VAR - #endif diff --git a/inst/include/Rcpp/api/meat/Rcpp_eval.h b/inst/include/Rcpp/api/meat/Rcpp_eval.h index 8eb08e0f0..6bd75e253 100644 --- a/inst/include/Rcpp/api/meat/Rcpp_eval.h +++ b/inst/include/Rcpp/api/meat/Rcpp_eval.h @@ -1,4 +1,5 @@ -// Copyright (C) 2013 Romain Francois +// Copyright (C) 2013 - 2025 Romain Francois +// Copyright (C) 2026 Romain Francois, Dirk Eddelbuettel and Iñaki Ucar // // This file is part of Rcpp. // @@ -24,8 +25,6 @@ namespace Rcpp { namespace internal { -#ifdef RCPP_USING_UNWIND_PROTECT - struct EvalData { SEXP expr; SEXP env; @@ -38,49 +37,25 @@ inline SEXP Rcpp_protected_eval(void* eval_data) { } // This is used internally instead of Rf_eval() to make evaluation safer -inline SEXP Rcpp_eval_impl(SEXP expr, SEXP env) { - return Rcpp_fast_eval(expr, env); -} - -#else // R < 3.5.0 - -// Fall back to Rf_eval() when the protect-unwind API is unavailable -inline SEXP Rcpp_eval_impl(SEXP expr, SEXP env) { - return ::Rf_eval(expr, env); +inline SEXP Rcpp_eval_impl(SEXP expr, SEXP env) { // #nocov + return Rcpp_fast_eval(expr, env); // #nocov } -#endif - }} // namespace Rcpp::internal namespace Rcpp { -#ifdef RCPP_USING_UNWIND_PROTECT - inline SEXP Rcpp_fast_eval(SEXP expr, SEXP env) { internal::EvalData data(expr, env); return unwindProtect(&internal::Rcpp_protected_eval, &data); } -#else - -inline SEXP Rcpp_fast_eval(SEXP expr, SEXP env) { - return Rcpp_eval(expr, env); -} - -#endif - - inline SEXP Rcpp_eval(SEXP expr, SEXP env) { // 'identity' function used to capture errors, interrupts Shield identity(Rf_findFun(::Rf_install("identity"), R_BaseNamespace)); - if (identity == R_UnboundValue) { - stop("Failed to find 'base::identity()'"); - } - // define the evalq call -- the actual R evaluation we want to execute Shield evalqCall(Rf_lang3(::Rf_install("evalq"), expr, env)); diff --git a/inst/include/Rcpp/as.h b/inst/include/Rcpp/as.h index 466761efb..e6990312c 100644 --- a/inst/include/Rcpp/as.h +++ b/inst/include/Rcpp/as.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // as.h: Rcpp R/C++ interface class library -- convert SEXP to C++ objects // -// Copyright (C) 2009 - 2015 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2009 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -30,8 +29,8 @@ namespace Rcpp { template T primitive_as(SEXP x) { if (::Rf_length(x) != 1) { - const char* fmt = "Expecting a single value: [extent=%i]."; - throw ::Rcpp::not_compatible(fmt, ::Rf_length(x)); + const char* fmt = "Expecting a single value: [extent=%i]."; // #nocov + throw ::Rcpp::not_compatible(fmt, ::Rf_length(x)); // #nocov } const int RTYPE = ::Rcpp::traits::r_sexptype_traits::rtype; Shield y(r_cast(x)); @@ -45,14 +44,14 @@ namespace Rcpp { } inline const char* check_single_string(SEXP x) { - if (TYPEOF(x) == CHARSXP) return CHAR(x); + if (TYPEOF(x) == CHARSXP) return CHAR(x); // #nocov start if (! ::Rf_isString(x) || Rf_length(x) != 1) { const char* fmt = "Expecting a single string value: " "[type=%s; extent=%i]."; throw ::Rcpp::not_compatible(fmt, Rf_type2char(TYPEOF(x)), Rf_length(x)); - } + } // #nocov end return CHAR(STRING_ELT(::Rcpp::r_cast(x), 0)); } diff --git a/inst/include/Rcpp/config.h b/inst/include/Rcpp/config.h index 1f34603ac..4b5ec4316 100644 --- a/inst/include/Rcpp/config.h +++ b/inst/include/Rcpp/config.h @@ -1,7 +1,7 @@ // config.h: Rcpp R/C++ interface class library -- Rcpp configuration // -// Copyright (C) 2010 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010-2026 Dirk Eddelbuettel and Romain François // // This file is part of Rcpp. // @@ -26,11 +26,11 @@ #define RcppDevVersion(maj, min, rev, dev) (((maj)*1000000) + ((min)*10000) + ((rev)*100) + (dev)) // the currently released version -#define RCPP_VERSION Rcpp_Version(1,0,13) -#define RCPP_VERSION_STRING "1.0.13" +#define RCPP_VERSION Rcpp_Version(1,1,1) +#define RCPP_VERSION_STRING "1.1.1" // the current source snapshot (using four components, if a fifth is used in DESCRIPTION we ignore it) -#define RCPP_DEV_VERSION RcppDevVersion(1,0,13,0) -#define RCPP_DEV_VERSION_STRING "1.0.13.0" +#define RCPP_DEV_VERSION RcppDevVersion(1,1,1,9) +#define RCPP_DEV_VERSION_STRING "1.1.1.9" #endif diff --git a/inst/include/Rcpp/date_datetime/Datetime.h b/inst/include/Rcpp/date_datetime/Datetime.h index e7d9ff00b..c0c4589cf 100644 --- a/inst/include/Rcpp/date_datetime/Datetime.h +++ b/inst/include/Rcpp/date_datetime/Datetime.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // Datetime.h: Rcpp R/C++ interface class library -- Datetime (POSIXct) // -// Copyright (C) 2010 - 2016 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -94,7 +93,7 @@ namespace Rcpp { private: double m_dt; // fractional seconds since epoch struct tm m_tm; // standard time representation - unsigned int m_us; // microsecond (to complement m_tm) + int m_us; // microsecond (to complement m_tm) // update m_tm based on m_dt void update_tm() { diff --git a/inst/include/Rcpp/date_datetime/newDateVector.h b/inst/include/Rcpp/date_datetime/newDateVector.h index 1b380aaab..89e3138ea 100644 --- a/inst/include/Rcpp/date_datetime/newDateVector.h +++ b/inst/include/Rcpp/date_datetime/newDateVector.h @@ -2,7 +2,7 @@ // // newDateVector.h: Rcpp R/C++ interface class library -- Date vector support // -// Copyright (C) 2016 Dirk Eddelbuettel +// Copyright (C) 2016 - 2025 Dirk Eddelbuettel // // This file is part of Rcpp. // @@ -28,6 +28,10 @@ namespace Rcpp { class newDateVector : public NumericVector { public: + newDateVector() : NumericVector() { + setClass(); + } + template newDateVector(const VectorBase& vec) : NumericVector(vec) { setClass(); diff --git a/inst/include/Rcpp/date_datetime/newDatetimeVector.h b/inst/include/Rcpp/date_datetime/newDatetimeVector.h index 224cf8929..efbae149c 100644 --- a/inst/include/Rcpp/date_datetime/newDatetimeVector.h +++ b/inst/include/Rcpp/date_datetime/newDatetimeVector.h @@ -28,10 +28,14 @@ namespace Rcpp { class newDatetimeVector : public NumericVector { public: + newDatetimeVector(const char* tz = "") : NumericVector() { + setClass(tz); + } + template newDatetimeVector(const VectorBase& other, const char* tz = "") : NumericVector(other) { - setClass(tz); + setClass(tz); } newDatetimeVector(SEXP vec, const char* tz = "") : diff --git a/inst/include/Rcpp/exceptions.h b/inst/include/Rcpp/exceptions.h index 6e0774482..2311442e3 100644 --- a/inst/include/Rcpp/exceptions.h +++ b/inst/include/Rcpp/exceptions.h @@ -2,7 +2,8 @@ // exceptions.h: Rcpp R/C++ interface class library -- exceptions // // Copyright (C) 2010 - 2020 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2021 - 2020 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +// Copyright (C) 2021 - 2024 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +// Copyright (C) 2025 - 2026 Dirk Eddelbuettel, Romain Francois, Iñaki Ucar and James J Balamuta // // This file is part of Rcpp. // @@ -150,9 +151,7 @@ inline void resumeJump(SEXP token) { token = getLongjumpToken(token); } ::R_ReleaseObject(token); -#if (defined(R_VERSION) && R_VERSION >= R_Version(3, 5, 0)) ::R_ContinueUnwind(token); -#endif // #nocov end Rf_error("Internal error: Rcpp longjump failed to resume"); } @@ -170,19 +169,30 @@ struct LongjumpException { } }; -} // namespace Rcpp + #define RCPP_ADVANCED_EXCEPTION_CLASS(__CLASS__, __WHAT__) \ + class __CLASS__ : public std::exception { \ + public: \ + __CLASS__( ) throw() : message( std::string(__WHAT__) + "." ){} \ + __CLASS__( const std::string& message ) throw() : \ + message( std::string(__WHAT__) + ": " + message + "."){} \ + template \ + __CLASS__( const char* fmt, Args&&... args ) throw() : \ + message( tfm::format(fmt, std::forward(args)... ) ){} \ + virtual ~__CLASS__() throw(){} \ + virtual const char* what() const throw() { return message.c_str(); } \ + private: \ + std::string message; \ + }; + template + inline void warning(const char* fmt, Args&&... args ) { + Rf_warning("%s", tfm::format(fmt, std::forward(args)... ).c_str()); + } // #nocov end -// Determine whether to use variadic templated RCPP_ADVANCED_EXCEPTION_CLASS, -// warning, and stop exception functions or to use the generated argument macro -// based on whether the compiler supports c++11 or not. -#if __cplusplus >= 201103L -# include -#else -# include -#endif - -namespace Rcpp { + template + inline void NORET stop(const char* fmt, Args&&... args) { + throw Rcpp::exception( tfm::format(fmt, std::forward(args)... ).c_str() ); + } #define RCPP_EXCEPTION_CLASS(__CLASS__,__WHAT__) \ class __CLASS__ : public std::exception{ \ diff --git a/inst/include/Rcpp/exceptions/cpp11/exceptions.h b/inst/include/Rcpp/exceptions/cpp11/exceptions.h deleted file mode 100644 index 79a42e05e..000000000 --- a/inst/include/Rcpp/exceptions/cpp11/exceptions.h +++ /dev/null @@ -1,56 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// exceptions.h: Rcpp R/C++ interface class library -- exceptions -// -// Copyright (C) 2017 James J Balamuta -// -// 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 . - -#ifndef Rcpp__exceptionscpp11__h -#define Rcpp__exceptionscpp11__h - -// Required for std::forward -#include - -namespace Rcpp { - -#define RCPP_ADVANCED_EXCEPTION_CLASS(__CLASS__, __WHAT__) \ -class __CLASS__ : public std::exception { \ - public: \ - __CLASS__( ) throw() : message( std::string(__WHAT__) + "." ){} \ - __CLASS__( const std::string& message ) throw() : \ - message( std::string(__WHAT__) + ": " + message + "."){} \ - template \ - __CLASS__( const char* fmt, Args&&... args ) throw() : \ - message( tfm::format(fmt, std::forward(args)... ) ){} \ - virtual ~__CLASS__() throw(){} \ - virtual const char* what() const throw() { return message.c_str(); } \ - private: \ - std::string message; \ -}; - -template -inline void warning(const char* fmt, Args&&... args ) { - Rf_warning("%s", tfm::format(fmt, std::forward(args)... ).c_str()); -} - -template -inline void NORET stop(const char* fmt, Args&&... args) { - throw Rcpp::exception( tfm::format(fmt, std::forward(args)... ).c_str() ); -} - -} // namespace Rcpp -#endif diff --git a/inst/include/Rcpp/exceptions/cpp98/exceptions.h b/inst/include/Rcpp/exceptions/cpp98/exceptions.h deleted file mode 100644 index 79fc827d5..000000000 --- a/inst/include/Rcpp/exceptions/cpp98/exceptions.h +++ /dev/null @@ -1,177 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// exceptions.h: Rcpp R/C++ interface class library -- exceptions -// -// Copyright (C) 2010 - 2017 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2017 Dirk Eddelbuettel, Romain Francois, and James J Balamuta -// -// 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 . - -#ifndef Rcpp__exceptionscpp98__h -#define Rcpp__exceptionscpp98__h - -namespace Rcpp { - -#define RCPP_ADVANCED_EXCEPTION_CLASS(__CLASS__, __WHAT__) \ -class __CLASS__ : public std::exception{ \ - public: \ - __CLASS__( ) throw() : message( std::string(__WHAT__) + "." ){} \ - __CLASS__( const std::string& message ) throw() : message( std::string(__WHAT__) + ": " + message + "." ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1) throw() : \ - message( tfm::format(fmt, arg1 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2) throw() : \ - message( tfm::format(fmt, arg1, arg2 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3, arg4 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3, arg4, arg5 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8, const T9& arg9) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ) ){} \ - template \ - __CLASS__(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8, const T9& arg9, const T10& arg10) throw() : \ - message( tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10 ) ){} \ - virtual ~__CLASS__() throw(){} \ - virtual const char* what() const throw() { return message.c_str() ; } \ - private: \ - std::string message ; \ -} ; \ - -// -- Start Rcpp::warning declaration - -template -inline void warning(const char* fmt, const T1& arg1) { - Rf_warning("%s", tfm::format(fmt, arg1).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3, arg4).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3, arg4, arg5).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8, const T9& arg9) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).c_str()); -} - -template -inline void warning(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8, const T9& arg9, const T10& arg10) { - Rf_warning("%s", tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10).c_str()); -} - -// -- End Rcpp::warning declaration - -// -- Start Rcpp::stop declaration - -template -inline void NORET stop(const char* fmt, const T1& arg1) { - throw Rcpp::exception(tfm::format(fmt, arg1).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3, arg4).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3, arg4, arg5).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8, const T9& arg9) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9).c_str()); -} - -template -inline void NORET stop(const char* fmt, const T1& arg1, const T2& arg2, const T3& arg3, const T4& arg4, const T5& arg5, const T6& arg6, const T7& arg7, const T8& arg8, const T9& arg9, const T10& arg10) { - throw Rcpp::exception(tfm::format(fmt, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10).c_str()); -} - -// -- End Rcpp::stop declaration -} // namespace Rcpp -#endif diff --git a/inst/include/Rcpp/exceptions_impl.h b/inst/include/Rcpp/exceptions_impl.h index 8f4502809..9fe071518 100644 --- a/inst/include/Rcpp/exceptions_impl.h +++ b/inst/include/Rcpp/exceptions_impl.h @@ -1,7 +1,8 @@ // exceptions_impl.h: Rcpp R/C++ interface class library -- exceptions // // Copyright (C) 2012 - 2019 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2020 Dirk Eddelbuettel, Romain Francois, and Joshua N. Pritikin +// Copyright (C) 2020 - 2024 Dirk Eddelbuettel, Romain Francois, and Joshua N. Pritikin +// Copyright (C) 2025 - 2026 Dirk Eddelbuettel, Romain Francois, Joshua N. Pritikin, and Iñaki Ucar // // This file is part of Rcpp. // @@ -21,25 +22,34 @@ #ifndef Rcpp__exceptions_impl__h #define Rcpp__exceptions_impl__h -// disable demangler on platforms where we have no support +// enable demangler on platforms where execinfo.h is present +// and that are not actively blacklisted #ifndef RCPP_DEMANGLER_ENABLED -# if defined(_WIN32) || \ - defined(__FreeBSD__) || \ - defined(__NetBSD__) || \ - defined(__OpenBSD__) || \ - defined(__CYGWIN__) || \ - defined(__sun) || \ - defined(_AIX) || \ - defined(__MUSL__) || \ - defined(__HAIKU__) || \ - defined(__ANDROID__) -# define RCPP_DEMANGLER_ENABLED 0 -# elif defined(__GNUC__) || defined(__clang__) -# include -# define RCPP_DEMANGLER_ENABLED 1 -# else -# define RCPP_DEMANGLER_ENABLED 0 -# endif +// set a fallback default +#define RCPP_DEMANGLER_ENABLED 0 +# if defined(_WIN32) || \ + defined(__FreeBSD__) || \ + defined(__NetBSD__) || \ + defined(__OpenBSD__) || \ + defined(__DragonFly__) || \ + defined(__CYGWIN__) || \ + defined(__sun) || \ + defined(_AIX) || \ + defined(__MUSL__) || \ + defined(__HAIKU__) || \ + defined(__ANDROID__) +// nothing to do here so just redefining +# undef RCPP_DEMANGLER_ENABLED +# define RCPP_DEMANGLER_ENABLED 0 +# elif defined __has_include +// if we can test for headers +# if __has_include () +// if we have the header, include and use it +# include +# undef RCPP_DEMANGLER_ENABLED +# define RCPP_DEMANGLER_ENABLED 1 +# endif +# endif #endif namespace Rcpp { diff --git a/inst/include/Rcpp/generated/DataFrame_generated.h b/inst/include/Rcpp/generated/DataFrame_generated.h deleted file mode 100644 index a12fd3d35..000000000 --- a/inst/include/Rcpp/generated/DataFrame_generated.h +++ /dev/null @@ -1,147 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// DataFrame_generated.h: Rcpp R/C++ interface class library -- data frames -// -// Copyright (C) 2010 - 2013 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 . - - -#ifndef Rcpp__DataFrame_generated_h -#define Rcpp__DataFrame_generated_h - - -template -static DataFrame_Impl create( const T1& t1 ) { - return DataFrame_Impl::from_list( Parent::create( t1 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19 ) ) ; -} - - -template -static DataFrame_Impl create( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20 ) { - return DataFrame_Impl::from_list( Parent::create( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20 ) ) ; -} - -#endif - diff --git a/inst/include/Rcpp/generated/DottedPair__ctors.h b/inst/include/Rcpp/generated/DottedPair__ctors.h deleted file mode 100644 index 00f7b27dc..000000000 --- a/inst/include/Rcpp/generated/DottedPair__ctors.h +++ /dev/null @@ -1,125 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// DottedPair_Impl__ctors.h: Rcpp R/C++ interface class library -- generated helper code for DottedPair_Impl.h -// -// Copyright (C) 2010 - 2013 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 . - -#ifndef Rcpp__generated__DottedPair_Impl_ctors_h -#define Rcpp__generated__DottedPair_Impl_ctors_h - - template - DottedPair_Impl( const T1& t1 ){ - Storage::set__( pairlist( t1 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2 ){ - Storage::set__( pairlist( t1, t2 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3 ){ - Storage::set__( pairlist( t1, t2, t3 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4 ){ - Storage::set__( pairlist( t1, t2, t3, t4 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19 ) ) ; - } - - template - DottedPair_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20 ) ) ; - } - -#endif diff --git a/inst/include/Rcpp/generated/Function__operator.h b/inst/include/Rcpp/generated/Function__operator.h deleted file mode 100644 index e17f34457..000000000 --- a/inst/include/Rcpp/generated/Function__operator.h +++ /dev/null @@ -1,135 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Function__operator.h: Rcpp R/C++ interface class library -- generated helper code for Function.h -// -// Copyright (C) 2010 - 2013 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 . - -#ifndef Rcpp__generated__Function_operator_h -#define Rcpp__generated__Function_operator_h - -/* - - template - SEXP operator()(ARGUMENTS){ - return invoke(pairlist(PARAMETERS), R_GlobalEnv); - } - -*/ - template - SEXP operator()(const T1& t1) const { - return invoke(pairlist(t1), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2) const { - return invoke(pairlist(t1, t2), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3) const { - return invoke(pairlist(t1, t2, t3), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4) const { - return invoke(pairlist(t1, t2, t3, t4), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) const { - return invoke(pairlist(t1, t2, t3, t4, t5), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20) const { - return invoke(pairlist(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20), R_GlobalEnv); - } - -/* */ - -#endif diff --git a/inst/include/Rcpp/generated/InternalFunctionWithStdFunction_call.h b/inst/include/Rcpp/generated/InternalFunctionWithStdFunction_call.h deleted file mode 100644 index c4605c330..000000000 --- a/inst/include/Rcpp/generated/InternalFunctionWithStdFunction_call.h +++ /dev/null @@ -1,2570 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// InternalFunctionWithStdFunction_call.h -- generated helper code for -// InternalFunctionWithStdFunction.h -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 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 . - -#ifndef Rcpp__generated__InternalFunctionWithStdFunction_calls_h -#define Rcpp__generated__InternalFunctionWithStdFunction_calls_h - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - return fun(); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - return fun(x0); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - return fun(x0,x1); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - return fun(x0,x1,x2); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - return fun(x0,x1,x2,x3); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - return fun(x0,x1,x2,x3,x4); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - return fun(x0,x1,x2,x3,x4,x5); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - return fun(x0,x1,x2,x3,x4,x5,x6); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - typename traits::input_parameter::type x58(args[58]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - typename traits::input_parameter::type x58(args[58]); - typename traits::input_parameter::type x59(args[59]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - typename traits::input_parameter::type x58(args[58]); - typename traits::input_parameter::type x59(args[59]); - typename traits::input_parameter::type x60(args[60]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - typename traits::input_parameter::type x58(args[58]); - typename traits::input_parameter::type x59(args[59]); - typename traits::input_parameter::type x60(args[60]); - typename traits::input_parameter::type x61(args[61]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - typename traits::input_parameter::type x58(args[58]); - typename traits::input_parameter::type x59(args[59]); - typename traits::input_parameter::type x60(args[60]); - typename traits::input_parameter::type x61(args[61]); - typename traits::input_parameter::type x62(args[62]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - typename traits::input_parameter::type x58(args[58]); - typename traits::input_parameter::type x59(args[59]); - typename traits::input_parameter::type x60(args[60]); - typename traits::input_parameter::type x61(args[61]); - typename traits::input_parameter::type x62(args[62]); - typename traits::input_parameter::type x63(args[63]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63); - } - - - template - RESULT_TYPE call(const std::function &fun, SEXP* args) { - typename traits::input_parameter::type x0(args[0]); - typename traits::input_parameter::type x1(args[1]); - typename traits::input_parameter::type x2(args[2]); - typename traits::input_parameter::type x3(args[3]); - typename traits::input_parameter::type x4(args[4]); - typename traits::input_parameter::type x5(args[5]); - typename traits::input_parameter::type x6(args[6]); - typename traits::input_parameter::type x7(args[7]); - typename traits::input_parameter::type x8(args[8]); - typename traits::input_parameter::type x9(args[9]); - typename traits::input_parameter::type x10(args[10]); - typename traits::input_parameter::type x11(args[11]); - typename traits::input_parameter::type x12(args[12]); - typename traits::input_parameter::type x13(args[13]); - typename traits::input_parameter::type x14(args[14]); - typename traits::input_parameter::type x15(args[15]); - typename traits::input_parameter::type x16(args[16]); - typename traits::input_parameter::type x17(args[17]); - typename traits::input_parameter::type x18(args[18]); - typename traits::input_parameter::type x19(args[19]); - typename traits::input_parameter::type x20(args[20]); - typename traits::input_parameter::type x21(args[21]); - typename traits::input_parameter::type x22(args[22]); - typename traits::input_parameter::type x23(args[23]); - typename traits::input_parameter::type x24(args[24]); - typename traits::input_parameter::type x25(args[25]); - typename traits::input_parameter::type x26(args[26]); - typename traits::input_parameter::type x27(args[27]); - typename traits::input_parameter::type x28(args[28]); - typename traits::input_parameter::type x29(args[29]); - typename traits::input_parameter::type x30(args[30]); - typename traits::input_parameter::type x31(args[31]); - typename traits::input_parameter::type x32(args[32]); - typename traits::input_parameter::type x33(args[33]); - typename traits::input_parameter::type x34(args[34]); - typename traits::input_parameter::type x35(args[35]); - typename traits::input_parameter::type x36(args[36]); - typename traits::input_parameter::type x37(args[37]); - typename traits::input_parameter::type x38(args[38]); - typename traits::input_parameter::type x39(args[39]); - typename traits::input_parameter::type x40(args[40]); - typename traits::input_parameter::type x41(args[41]); - typename traits::input_parameter::type x42(args[42]); - typename traits::input_parameter::type x43(args[43]); - typename traits::input_parameter::type x44(args[44]); - typename traits::input_parameter::type x45(args[45]); - typename traits::input_parameter::type x46(args[46]); - typename traits::input_parameter::type x47(args[47]); - typename traits::input_parameter::type x48(args[48]); - typename traits::input_parameter::type x49(args[49]); - typename traits::input_parameter::type x50(args[50]); - typename traits::input_parameter::type x51(args[51]); - typename traits::input_parameter::type x52(args[52]); - typename traits::input_parameter::type x53(args[53]); - typename traits::input_parameter::type x54(args[54]); - typename traits::input_parameter::type x55(args[55]); - typename traits::input_parameter::type x56(args[56]); - typename traits::input_parameter::type x57(args[57]); - typename traits::input_parameter::type x58(args[58]); - typename traits::input_parameter::type x59(args[59]); - typename traits::input_parameter::type x60(args[60]); - typename traits::input_parameter::type x61(args[61]); - typename traits::input_parameter::type x62(args[62]); - typename traits::input_parameter::type x63(args[63]); - typename traits::input_parameter::type x64(args[64]); - return fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63,x64); - } - - -#endif - diff --git a/inst/include/Rcpp/generated/InternalFunction__ctors.h b/inst/include/Rcpp/generated/InternalFunction__ctors.h deleted file mode 100644 index a86ad3a0e..000000000 --- a/inst/include/Rcpp/generated/InternalFunction__ctors.h +++ /dev/null @@ -1,487 +0,0 @@ - -// InternalFunction_Impl_ctors.h -- generated helper code for InternalFunction__ctors.h -// see rcpp-scripts repo for generator script -// also hand-edited so check generator state -// -// Copyright (C) 2010 - 2020 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 . - -#ifndef Rcpp__generated__InternalFunction_Impl_ctors_h -#define Rcpp__generated__InternalFunction_Impl_ctors_h - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(void)) { - set(XPtr >(new CppFunction0(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0)) { - set(XPtr >(new CppFunction1(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1)) { - set(XPtr >(new CppFunction2(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2)) { - set(XPtr >(new CppFunction3(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3)) { - set(XPtr >(new CppFunction4(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4)) { - set(XPtr >(new CppFunction5(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5)) { - set(XPtr >(new CppFunction6(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6)) { - set(XPtr >(new CppFunction7(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7)) { - set(XPtr >(new CppFunction8(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8)) { - set(XPtr >(new CppFunction9(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9)) { - set(XPtr >(new CppFunction10(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10)) { - set(XPtr >(new CppFunction11(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11)) { - set(XPtr >(new CppFunction12(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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)) { - set(XPtr >(new CppFunction13(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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)) { - set(XPtr >(new CppFunction14(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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)) { - set(XPtr >(new CppFunction15(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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)) { - set(XPtr >(new CppFunction16(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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)) { - set(XPtr >(new CppFunction17(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17)) { - set(XPtr >(new CppFunction18(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18)) { - set(XPtr >(new CppFunction19(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19)) { - set(XPtr >(new CppFunction20(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20)) { - set(XPtr >(new CppFunction21(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21)) { - set(XPtr >(new CppFunction22(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22)) { - set(XPtr >(new CppFunction23(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23)) { - set(XPtr >(new CppFunction24(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24)) { - set(XPtr >(new CppFunction25(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25)) { - set(XPtr >(new CppFunction26(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26)) { - set(XPtr >(new CppFunction27(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27)) { - set(XPtr >(new CppFunction28(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28)) { - set(XPtr >(new CppFunction29(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29)) { - set(XPtr >(new CppFunction30(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30)) { - set(XPtr >(new CppFunction31(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31)) { - set(XPtr >(new CppFunction32(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32)) { - set(XPtr >(new CppFunction33(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33)) { - set(XPtr >(new CppFunction34(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34)) { - set(XPtr >(new CppFunction35(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35)) { - set(XPtr >(new CppFunction36(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36)) { - set(XPtr >(new CppFunction37(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37)) { - set(XPtr >(new CppFunction38(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38)) { - set(XPtr >(new CppFunction39(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39)) { - set(XPtr >(new CppFunction40(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40)) { - set(XPtr >(new CppFunction41(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41)) { - set(XPtr >(new CppFunction42(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42)) { - set(XPtr >(new CppFunction43(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43)) { - set(XPtr >(new CppFunction44(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44)) { - set(XPtr >(new CppFunction45(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45)) { - set(XPtr >(new CppFunction46(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46)) { - set(XPtr >(new CppFunction47(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47)) { - set(XPtr >(new CppFunction48(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48)) { - set(XPtr >(new CppFunction49(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49)) { - set(XPtr >(new CppFunction50(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50)) { - set(XPtr >(new CppFunction51(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51)) { - set(XPtr >(new CppFunction52(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52)) { - set(XPtr >(new CppFunction53(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53)) { - set(XPtr >(new CppFunction54(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54)) { - set(XPtr >(new CppFunction55(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55)) { - set(XPtr >(new CppFunction56(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56)) { - set(XPtr >(new CppFunction57(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57)) { - set(XPtr >(new CppFunction58(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58)) { - set(XPtr >(new CppFunction59(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59)) { - set(XPtr >(new CppFunction60(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60)) { - set(XPtr >(new CppFunction61(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61)) { - set(XPtr >(new CppFunction62(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62)) { - set(XPtr >(new CppFunction63(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63)) { - set(XPtr >(new CppFunction64(fun), true)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64)) { - set(XPtr >(new CppFunction65(fun), true)); - } - - -#endif diff --git a/inst/include/Rcpp/generated/Language__ctors.h b/inst/include/Rcpp/generated/Language__ctors.h deleted file mode 100644 index 7076c7aec..000000000 --- a/inst/include/Rcpp/generated/Language__ctors.h +++ /dev/null @@ -1,241 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Language__ctors.h: Rcpp R/C++ interface class library -- generated helper code for Language.h -// -// Copyright (C) 2010 - 2013 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 . - -#ifndef Rcpp__generated__Language_ctors_h -#define Rcpp__generated__Language_ctors_h - - -/* - -template -Language_Impl( const std::string& symbol, ARGUMENTS) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), PARAMETERS) ) ; -} - -template -Language_Impl( const Function& function, ARGUMENTS) { - Storage::set__( pairlist( function, PARAMETERS) ); -} - -*/ - -template -Language_Impl( const std::string& symbol, const T1& t1) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1) ); -} - -template -Language_Impl( const Function& function, const T1& t1) { - Storage::set__( pairlist( function, t1) ) ; - -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2)); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2) { - Storage::set__( pairlist( function, t1, t2)) ; -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3) { - Storage::set__( pairlist( function, t1, t2, t3) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4) { - Storage::set__( pairlist( function, t1, t2, t3, t4) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19) ); -} - -template -Language_Impl( const std::string& symbol, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20) { - Storage::set__( pairlist(Rf_install( symbol.c_str() ), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) ); -} - -template -Language_Impl( const Function& function, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20) { - Storage::set__( pairlist( function, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) ); -} - -#endif diff --git a/inst/include/Rcpp/generated/Pairlist__ctors.h b/inst/include/Rcpp/generated/Pairlist__ctors.h deleted file mode 100644 index e05132273..000000000 --- a/inst/include/Rcpp/generated/Pairlist__ctors.h +++ /dev/null @@ -1,125 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Pairlist__ctors.h: Rcpp R/C++ interface class library -- generated helper code for Pairlist.h -// -// Copyright (C) 2010 - 2013 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 . - -#ifndef Rcpp__generated__Pairlist_ctors_h -#define Rcpp__generated__Pairlist_ctors_h - - template - Pairlist_Impl( const T1& t1 ){ - Storage::set__( pairlist( t1 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2 ){ - Storage::set__( pairlist( t1, t2 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3 ){ - Storage::set__( pairlist( t1, t2, t3 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4 ){ - Storage::set__( pairlist( t1, t2, t3, t4 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19 ) ) ; - } - - template - Pairlist_Impl( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20 ){ - Storage::set__( pairlist( t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20 ) ) ; - } - -#endif diff --git a/inst/include/Rcpp/generated/Vector__create.h b/inst/include/Rcpp/generated/Vector__create.h deleted file mode 100644 index 66bccdfb5..000000000 --- a/inst/include/Rcpp/generated/Vector__create.h +++ /dev/null @@ -1,1235 +0,0 @@ - -// -// Vector__create.h: Rcpp R/C++ interface class library -- generated helper code for Vector.h -// -// Copyright (C) 2010 - 2020 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 . - -#ifndef Rcpp__generated__Vector_create_h -#define Rcpp__generated__Vector_create_h - -/* - -public: - - template - static Vector create(ARGUMENTS){ - return create__dispatch( typename traits::integral_constant::value }} - >::type(), PARAMETERS ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, ARGUMENTS ){ - Vector res(___N___) ; - iterator it( res.begin() ); - - //// - __FOR_EACH__{{ *it = converter_type::get(___X___) ; ++it ; }} - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, ARGUMENTS){ - Vector res( ___N___ ) ; - Shield names( ::Rf_allocVector( STRSXP, ___N___ ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - __FOR_EACH__{{ replace_element( it, names, index, ___X___ ) ; ++it; ++index ; }} - //// - - res.attr("names") = names ; - - return res ; - } - -*/ -public: - - template - static Vector create(const T1& t1){ - return create__dispatch( typename traits::integral_constant::value - >::type(), t1 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1 ){ - Vector res(1) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1){ - Vector res( 1 ) ; - Shield names( ::Rf_allocVector( STRSXP, 1 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2){ // #nocov start - return create__dispatch( typename traits::integral_constant::value || - traits::is_named::value - >::type(), t1, t2 ) ; // #nocov end - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2 ){ - Vector res(2) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - //// - - return res ; - } - - template // #nocov start - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2){ - Vector res( 2 ) ; - Shield names( ::Rf_allocVector( STRSXP, 2 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; // #nocov end - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3){ - return create__dispatch( typename traits::integral_constant::value || - traits::is_named::value || - traits::is_named::value - >::type(), t1, t2, t3 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3 ){ - Vector res(3) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3){ // #nocov start - Vector res( 3 ) ; - Shield names( ::Rf_allocVector( STRSXP, 3 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; // #nocov end - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4){ - return create__dispatch( typename traits::integral_constant::value || - traits::is_named::value || - traits::is_named::value || - traits::is_named::value - >::type(), t1, t2, t3, t4 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4 ){ - Vector res(4) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4){ - Vector res( 4 ) ; - Shield names( ::Rf_allocVector( STRSXP, 4 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5 ){ - Vector res(5) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5){ - Vector res( 5 ) ; - Shield names( ::Rf_allocVector( STRSXP, 5 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6 ){ - Vector res(6) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6){ - Vector res( 6 ) ; - Shield names( ::Rf_allocVector( STRSXP, 6 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7 ){ - Vector res(7) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7){ - Vector res( 7 ) ; - Shield names( ::Rf_allocVector( STRSXP, 7 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8 ){ - Vector res(8) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8){ - Vector res( 8 ) ; - Shield names( ::Rf_allocVector( STRSXP, 8 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9 ){ - Vector res(9) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9){ - Vector res( 9 ) ; - Shield names( ::Rf_allocVector( STRSXP, 9 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10 ){ - Vector res(10) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10){ - Vector res( 10 ) ; - Shield names( ::Rf_allocVector( STRSXP, 10 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11 ){ - Vector res(11) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11){ - Vector res( 11 ) ; - Shield names( ::Rf_allocVector( STRSXP, 11 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12 ){ - Vector res(12) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12){ - Vector res( 12 ) ; - Shield names( ::Rf_allocVector( STRSXP, 12 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13 ){ - Vector res(13) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13){ - Vector res( 13 ) ; - Shield names( ::Rf_allocVector( STRSXP, 13 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14 ){ - Vector res(14) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - *it = converter_type::get(t14) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14){ - Vector res( 14 ) ; - Shield names( ::Rf_allocVector( STRSXP, 14 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - replace_element( it, names, index, t14 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15 ){ - Vector res(15) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - *it = converter_type::get(t14) ; ++it ; - *it = converter_type::get(t15) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15){ - Vector res( 15 ) ; - Shield names( ::Rf_allocVector( STRSXP, 15 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - replace_element( it, names, index, t14 ) ; ++it; ++index ; - replace_element( it, names, index, t15 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16 ){ - Vector res(16) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - *it = converter_type::get(t14) ; ++it ; - *it = converter_type::get(t15) ; ++it ; - *it = converter_type::get(t16) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16){ - Vector res( 16 ) ; - Shield names( ::Rf_allocVector( STRSXP, 16 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - replace_element( it, names, index, t14 ) ; ++it; ++index ; - replace_element( it, names, index, t15 ) ; ++it; ++index ; - replace_element( it, names, index, t16 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17 ){ - Vector res(17) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - *it = converter_type::get(t14) ; ++it ; - *it = converter_type::get(t15) ; ++it ; - *it = converter_type::get(t16) ; ++it ; - *it = converter_type::get(t17) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17){ - Vector res( 17 ) ; - Shield names( ::Rf_allocVector( STRSXP, 17 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - replace_element( it, names, index, t14 ) ; ++it; ++index ; - replace_element( it, names, index, t15 ) ; ++it; ++index ; - replace_element( it, names, index, t16 ) ; ++it; ++index ; - replace_element( it, names, index, t17 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18 ){ - Vector res(18) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - *it = converter_type::get(t14) ; ++it ; - *it = converter_type::get(t15) ; ++it ; - *it = converter_type::get(t16) ; ++it ; - *it = converter_type::get(t17) ; ++it ; - *it = converter_type::get(t18) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18){ - Vector res( 18 ) ; - Shield names( ::Rf_allocVector( STRSXP, 18 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - replace_element( it, names, index, t14 ) ; ++it; ++index ; - replace_element( it, names, index, t15 ) ; ++it; ++index ; - replace_element( it, names, index, t16 ) ; ++it; ++index ; - replace_element( it, names, index, t17 ) ; ++it; ++index ; - replace_element( it, names, index, t18 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19 ){ - Vector res(19) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - *it = converter_type::get(t14) ; ++it ; - *it = converter_type::get(t15) ; ++it ; - *it = converter_type::get(t16) ; ++it ; - *it = converter_type::get(t17) ; ++it ; - *it = converter_type::get(t18) ; ++it ; - *it = converter_type::get(t19) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19){ - Vector res( 19 ) ; - Shield names( ::Rf_allocVector( STRSXP, 19 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - replace_element( it, names, index, t14 ) ; ++it; ++index ; - replace_element( it, names, index, t15 ) ; ++it; ++index ; - replace_element( it, names, index, t16 ) ; ++it; ++index ; - replace_element( it, names, index, t17 ) ; ++it; ++index ; - replace_element( it, names, index, t18 ) ; ++it; ++index ; - replace_element( it, names, index, t19 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -public: - - template - static Vector create(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value || traits::is_named::value - >::type(), t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20 ) ; - } - -private: - - template - static Vector create__dispatch( traits::false_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20 ){ - Vector res(20) ; - iterator it( res.begin() ); - - //// - *it = converter_type::get(t1) ; ++it ; - *it = converter_type::get(t2) ; ++it ; - *it = converter_type::get(t3) ; ++it ; - *it = converter_type::get(t4) ; ++it ; - *it = converter_type::get(t5) ; ++it ; - *it = converter_type::get(t6) ; ++it ; - *it = converter_type::get(t7) ; ++it ; - *it = converter_type::get(t8) ; ++it ; - *it = converter_type::get(t9) ; ++it ; - *it = converter_type::get(t10) ; ++it ; - *it = converter_type::get(t11) ; ++it ; - *it = converter_type::get(t12) ; ++it ; - *it = converter_type::get(t13) ; ++it ; - *it = converter_type::get(t14) ; ++it ; - *it = converter_type::get(t15) ; ++it ; - *it = converter_type::get(t16) ; ++it ; - *it = converter_type::get(t17) ; ++it ; - *it = converter_type::get(t18) ; ++it ; - *it = converter_type::get(t19) ; ++it ; - *it = converter_type::get(t20) ; ++it ; - //// - - return res ; - } - - template - static Vector create__dispatch( traits::true_type, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20){ - Vector res( 20 ) ; - Shield names( ::Rf_allocVector( STRSXP, 20 ) ) ; - int index = 0 ; - iterator it( res.begin() ); - - //// - replace_element( it, names, index, t1 ) ; ++it; ++index ; - replace_element( it, names, index, t2 ) ; ++it; ++index ; - replace_element( it, names, index, t3 ) ; ++it; ++index ; - replace_element( it, names, index, t4 ) ; ++it; ++index ; - replace_element( it, names, index, t5 ) ; ++it; ++index ; - replace_element( it, names, index, t6 ) ; ++it; ++index ; - replace_element( it, names, index, t7 ) ; ++it; ++index ; - replace_element( it, names, index, t8 ) ; ++it; ++index ; - replace_element( it, names, index, t9 ) ; ++it; ++index ; - replace_element( it, names, index, t10 ) ; ++it; ++index ; - replace_element( it, names, index, t11 ) ; ++it; ++index ; - replace_element( it, names, index, t12 ) ; ++it; ++index ; - replace_element( it, names, index, t13 ) ; ++it; ++index ; - replace_element( it, names, index, t14 ) ; ++it; ++index ; - replace_element( it, names, index, t15 ) ; ++it; ++index ; - replace_element( it, names, index, t16 ) ; ++it; ++index ; - replace_element( it, names, index, t17 ) ; ++it; ++index ; - replace_element( it, names, index, t18 ) ; ++it; ++index ; - replace_element( it, names, index, t19 ) ; ++it; ++index ; - replace_element( it, names, index, t20 ) ; ++it; ++index ; - //// - - res.attr("names") = names ; - - return res ; - } - -/* */ - -#endif diff --git a/inst/include/Rcpp/generated/grow__pairlist.h b/inst/include/Rcpp/generated/grow__pairlist.h deleted file mode 100644 index 4b59cbb29..000000000 --- a/inst/include/Rcpp/generated/grow__pairlist.h +++ /dev/null @@ -1,135 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// grow__pairlist.h: Rcpp R/C++ interface class library -- generated helper code for grow.h -// -// Copyright (C) 2010 - 2011 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 . - -#ifndef Rcpp__generated__grow_pairlist_h -#define Rcpp__generated__grow_pairlist_h - -/* - -template -SEXP pairlist( ARGUMENTS ){ - return GROW ; -} - -*/ -template -SEXP pairlist( const T1& t1 ){ - return grow( t1, R_NilValue ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2 ){ - return grow( t1, grow( t2, R_NilValue ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3 ){ - return grow( t1, grow( t2, grow( t3, R_NilValue ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, R_NilValue ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, R_NilValue ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, R_NilValue ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, R_NilValue ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, R_NilValue ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, R_NilValue ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, R_NilValue ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, grow( t14, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, grow( t14, grow( t15, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, grow( t14, grow( t15, grow( t16, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, grow( t14, grow( t15, grow( t16, grow( t17, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, grow( t14, grow( t15, grow( t16, grow( t17, grow( t18, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, grow( t14, grow( t15, grow( t16, grow( t17, grow( t18, grow( t19, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -template -SEXP pairlist( const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10, const T11& t11, const T12& t12, const T13& t13, const T14& t14, const T15& t15, const T16& t16, const T17& t17, const T18& t18, const T19& t19, const T20& t20 ){ - return grow( t1, grow( t2, grow( t3, grow( t4, grow( t5, grow( t6, grow( t7, grow( t8, grow( t9, grow( t10, grow( t11, grow( t12, grow( t13, grow( t14, grow( t15, grow( t16, grow( t17, grow( t18, grow( t19, grow( t20, R_NilValue ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ) ; -} - -/* */ - -#endif diff --git a/inst/include/Rcpp/grow.h b/inst/include/Rcpp/grow.h index b67d05a69..de557f654 100644 --- a/inst/include/Rcpp/grow.h +++ b/inst/include/Rcpp/grow.h @@ -2,7 +2,7 @@ // // grow.h: Rcpp R/C++ interface class library -- grow a pairlist // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -70,18 +70,15 @@ namespace Rcpp { return grow(Rf_mkString(head), y); } - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - SEXP pairlist(const T1& t1) { - return grow( t1, R_NilValue ) ; - } - template - SEXP pairlist(const T& t1, const TArgs&... args) { - return grow(t1, pairlist(args...)); - } - #else - #include - #endif + template + SEXP pairlist(const T1& t1) { + return grow( t1, R_NilValue ) ; + } + + template + SEXP pairlist(const T& t1, const TArgs&... args) { + return grow(t1, pairlist(args...)); + } } // namespace Rcpp diff --git a/inst/include/Rcpp/hash/IndexHash.h b/inst/include/Rcpp/hash/IndexHash.h index de994cbbc..6bc73ed3d 100644 --- a/inst/include/Rcpp/hash/IndexHash.h +++ b/inst/include/Rcpp/hash/IndexHash.h @@ -4,7 +4,8 @@ // // Copyright (C) 2010, 2011 Simon Urbanek // Copyright (C) 2012 - 2013 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2014 - 2021 Dirk Eddelbuettel, Romain Francois and Kevin Ushey +// Copyright (C) 2014 - 2024 Dirk Eddelbuettel, Romain Francois and Kevin Ushey +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois, Kevin Ushey and Iñaki Ucar // // This file is part of Rcpp. // @@ -159,13 +160,15 @@ namespace Rcpp{ #endif } + STORAGE normalize(STORAGE val) const { return val; } + inline bool not_equal(const STORAGE& lhs, const STORAGE& rhs) { - return ! internal::NAEquals()(lhs, rhs); + return ! internal::NAEquals()(normalize(lhs), rhs); } bool add_value(int i){ RCPP_DEBUG_2( "%s::add_value(%d)", DEMANGLE(IndexHash), i ) - STORAGE val = src[i++] ; + STORAGE val = normalize(src[i++]); uint32_t addr = get_addr(val) ; while (data[addr] && not_equal( src[data[addr] - 1], val)) { addr++; @@ -199,6 +202,15 @@ namespace Rcpp{ uint32_t get_addr(STORAGE value) const ; } ; + template <> + inline double IndexHash::normalize(double val) const { + /* double is a bit tricky - we have to normalize 0.0, NA and NaN */ + if (val == 0.0) val = 0.0; + if (internal::Rcpp_IsNA(val)) val = NA_REAL; + else if (internal::Rcpp_IsNaN(val)) val = R_NaN; + return val; + } + template <> inline uint32_t IndexHash::get_addr(int value) const { return RCPP_HASH(value) ; @@ -211,10 +223,6 @@ namespace Rcpp{ uint32_t u[2]; }; union dint_u val_u; - /* double is a bit tricky - we nave to normalize 0.0, NA and NaN */ - if (val == 0.0) val = 0.0; - if (internal::Rcpp_IsNA(val)) val = NA_REAL; - else if (internal::Rcpp_IsNaN(val)) val = R_NaN; val_u.d = val; addr = RCPP_HASH(val_u.u[0] + val_u.u[1]); return addr ; diff --git a/inst/include/Rcpp/hash/SelfHash.h b/inst/include/Rcpp/hash/SelfHash.h index 20607277d..1f566da56 100644 --- a/inst/include/Rcpp/hash/SelfHash.h +++ b/inst/include/Rcpp/hash/SelfHash.h @@ -3,8 +3,9 @@ // hash.h: Rcpp R/C++ interface class library -- hashing utility, inspired // from Simon's fastmatch package // -// Copyright (C) 2010, 2011 Simon Urbanek -// Copyright (C) 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010, 2011 Simon Urbanek +// Copyright (C) 2012 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -60,10 +61,16 @@ namespace sugar{ std::vector indices ; int size_ ; + STORAGE normalize(STORAGE val) const { return val; } + + inline bool not_equal(const STORAGE& lhs, const STORAGE& rhs) { + return ! internal::NAEquals()(normalize(lhs), rhs); + } + int add_value_get_index(int i){ - STORAGE val = src[i++] ; + STORAGE val = normalize(src[i++]); unsigned int addr = get_addr(val) ; - while (data[addr] && src[data[addr] - 1] != val) { + while (data[addr] && not_equal( src[data[addr] - 1], val)) { addr++; if (addr == static_cast(m)) addr = 0; } @@ -90,6 +97,15 @@ namespace sugar{ unsigned int get_addr(STORAGE value) const ; } ; + template <> + inline double SelfHash::normalize(double val) const { + /* double is a bit tricky - we have to normalize 0.0, NA and NaN */ + if (val == 0.0) val = 0.0; + if (internal::Rcpp_IsNA(val)) val = NA_REAL; + else if (internal::Rcpp_IsNaN(val)) val = R_NaN; + return val; + } + template <> inline unsigned int SelfHash::get_addr(int value) const { return RCPP_HASH(value) ; @@ -102,10 +118,6 @@ namespace sugar{ unsigned int u[2]; }; union dint_u val_u; - /* double is a bit tricky - we nave to normalize 0.0, NA and NaN */ - if (val == 0.0) val = 0.0; - if (internal::Rcpp_IsNA(val)) val = NA_REAL; - else if (internal::Rcpp_IsNaN(val)) val = R_NaN; val_u.d = val; addr = RCPP_HASH(val_u.u[0] + val_u.u[1]); return addr ; diff --git a/inst/include/Rcpp/internal/call.h b/inst/include/Rcpp/internal/call.h index 05a22a0e9..9a75e1b11 100644 --- a/inst/include/Rcpp/internal/call.h +++ b/inst/include/Rcpp/internal/call.h @@ -4,18 +4,15 @@ #include #include -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - namespace Rcpp { namespace internal { // Utility struct so that we can pass a pack of types between functions template struct type_pack {}; - /** * This specialisation is for functions that return a value, whereas the below * is for void-returning functions. - * + * * The "* = nullptr" default argument allows both templates to be well-defined * regardless of which one is used. */ @@ -40,7 +37,7 @@ SEXP call_impl(const F& fun, SEXP* args, type_pack, * Helper for calling a function with an array of SEXP arguments, * where each argument is converted to the appropriate type before being passed * to the function. A compile-time sequence is used to index the SEXP array. - * + * * The function only needs the intended types of the result and arguments, * which allows the template to be used for function pointers, lambdas, and * `std::function` objects. @@ -54,5 +51,3 @@ SEXP call(const F& fun, SEXP* args) { } // namespace Rcpp #endif - -#endif diff --git a/inst/include/Rcpp/internal/caster.h b/inst/include/Rcpp/internal/caster.h index afd63ed39..771e9f1d8 100644 --- a/inst/include/Rcpp/internal/caster.h +++ b/inst/include/Rcpp/internal/caster.h @@ -1,9 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -/* :tabSize=4:indentSize=4:noTabs=false:folding=explicit:collapseFolds=1: */ -// + // caster.h: Rcpp R/C++ interface class library -- // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -26,9 +24,9 @@ namespace Rcpp{ namespace internal{ -template TO caster(FROM from){ +template TO caster(FROM from){ // #nocov start return static_cast(from) ; -} +} // #nocov end template inline Rcomplex Rcomplex_caster( std::complex from ){ @@ -67,4 +65,3 @@ inline std::complex caster >( Rcomplex from } #endif - diff --git a/inst/include/Rcpp/internal/export.h b/inst/include/Rcpp/internal/export.h index 46ce154c3..04d899433 100644 --- a/inst/include/Rcpp/internal/export.h +++ b/inst/include/Rcpp/internal/export.h @@ -77,11 +77,11 @@ namespace Rcpp{ template void export_range__dispatch( SEXP x, InputIterator first, ::Rcpp::traits::r_type_string_tag ) { - if( ! ::Rf_isString( x) ) { + if( ! ::Rf_isString( x) ) { // #nocov start const char* fmt = "Expecting a string vector: " "[type=%s; required=STRSXP]."; throw ::Rcpp::not_compatible(fmt, Rf_type2char(TYPEOF(x)) ); - } + } // #nocov end R_xlen_t n = ::Rf_xlength(x) ; for( R_xlen_t i=0; i::type* r_vector_start(SEXP x) { return reinterpret_cast(dataptr(x)); } -// add specializations to avoid use of dataptr -#define RCPP_VECTOR_START_IMPL(__RTYPE__, __ACCESSOR__) \ - template <> \ - inline typename Rcpp::traits::storage_type<__RTYPE__>::type* r_vector_start<__RTYPE__>(SEXP x) { \ - return __ACCESSOR__(x); \ - } - -RCPP_VECTOR_START_IMPL(LGLSXP, LOGICAL); -RCPP_VECTOR_START_IMPL(INTSXP, INTEGER); -RCPP_VECTOR_START_IMPL(RAWSXP, RAW); -RCPP_VECTOR_START_IMPL(CPLXSXP, COMPLEX); -RCPP_VECTOR_START_IMPL(REALSXP, REAL); - -#undef RCPP_VECTOR_START_IMPL - /** * The value 0 statically casted to the appropriate type for * the given SEXP type diff --git a/inst/include/Rcpp/internal/wrap.h b/inst/include/Rcpp/internal/wrap.h index 0c3b10fda..4567f2455 100644 --- a/inst/include/Rcpp/internal/wrap.h +++ b/inst/include/Rcpp/internal/wrap.h @@ -66,6 +66,12 @@ namespace Rcpp { return make_charsexp__impl__cstring(st.c_str()); } +#if __cplusplus >= 201703L + inline SEXP make_charsexp__impl__cstring(std::string_view st) { + return Rf_mkCharLen(st.data(), static_cast(st.size())); + } +#endif + template inline SEXP make_charsexp__impl(const T& s, Rcpp::traits::true_type) { return make_charsexp__impl__wstring(s); @@ -516,18 +522,12 @@ namespace Rcpp { * quite a cryptic message */ template - inline SEXP wrap_dispatch_unknown_iterable(const T& object, ::Rcpp::traits::false_type) { - RCPP_DEBUG_1("wrap_dispatch_unknown_iterable<%s>(., false )", DEMANGLE(T)) - // here we know that T is not convertible to SEXP - #ifdef HAS_STATIC_ASSERT - static_assert(!sizeof(T), "cannot convert type to SEXP"); - #else - // leave the cryptic message - SEXP x = object; - return x; - #endif - return R_NilValue; // -Wall - } + inline SEXP wrap_dispatch_unknown_iterable(const T& object, ::Rcpp::traits::false_type) { + RCPP_DEBUG_1("wrap_dispatch_unknown_iterable<%s>(., false )", DEMANGLE(T)) + // here we know that T is not convertible to SEXP + static_assert(!sizeof(T), "cannot convert type to SEXP"); + return R_NilValue; // -Wall + } template inline SEXP wrap_dispatch_unknown_iterable__logical(const T& object, ::Rcpp::traits::true_type) { @@ -930,7 +930,7 @@ namespace Rcpp { if (v != NULL) return Rf_mkString(v); else - return R_NilValue; // #nocov + return R_NilValue; // #nocov } /** diff --git a/inst/include/Rcpp/lgrow.h b/inst/include/Rcpp/lgrow.h new file mode 100644 index 000000000..f16499a9c --- /dev/null +++ b/inst/include/Rcpp/lgrow.h @@ -0,0 +1,77 @@ +// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- +// +// lgrow.h: Rcpp R/C++ interface class library -- grow a (LANGSXP) pairlist +// +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel, Romain Francois, and Kevin Ushey +// +// 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 . + +#ifndef Rcpp_lgrow_h +#define Rcpp_lgrow_h + +#include +#include + +namespace Rcpp { + +inline SEXP lgrow(SEXP head, SEXP tail) { + return Rf_lcons(head, tail); +} + +namespace internal { + +// for Named objects +template +inline SEXP lgrow__dispatch(Rcpp::traits::true_type, const T& head, SEXP tail) { + Shield y(wrap(head.object)); + Shield x(Rf_lcons(y, tail)); + SEXP headNameSym = Rf_install(head.name.c_str()); + SET_TAG(x, headNameSym); + return x; +} + +// for all other objects +template +inline SEXP lgrow__dispatch(Rcpp::traits::false_type, const T& head, SEXP tail) { + return lgrow(wrap(head), tail); +} + +} // internal + +template +SEXP lgrow(const T& head, SEXP tail) { + Shield y(tail); + return internal::lgrow__dispatch(typename traits::is_named::type(), head, y); +} + +inline SEXP lgrow(const char* head, SEXP tail) { + Shield y(tail); + return lgrow(Rf_mkString(head), y); +} + +template +SEXP langlist(const T1& t1) { + return lgrow(t1, R_NilValue); +} + +template +SEXP langlist(const T& t1, const TArgs&... args) { + return lgrow(t1, langlist(args...)); +} + +} // namespace Rcpp + +#endif diff --git a/inst/include/Rcpp/longlong.h b/inst/include/Rcpp/longlong.h index 711dff8a7..669489667 100644 --- a/inst/include/Rcpp/longlong.h +++ b/inst/include/Rcpp/longlong.h @@ -3,7 +3,7 @@ // longlong.h: Rcpp R/C++ interface class library -- long long support // // Copyright (C) 2013 - 2017 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2018 Dirk Eddelbuettel, Romain Francois and Kevin Ushey +// Copyright (C) 2018 - 2025 Dirk Eddelbuettel, Romain Francois and Kevin Ushey // // This file is part of Rcpp. // @@ -23,33 +23,8 @@ #ifndef RCPP_LONG_LONG_H #define RCPP_LONG_LONG_H -// long long is explicitly available to C++11 (and above) compilers -#if __cplusplus >= 201103L - typedef long long int rcpp_long_long_type; typedef unsigned long long int rcpp_ulong_long_type; # define RCPP_HAS_LONG_LONG_TYPES -// GNU compilers may make 'long long' available as an extension -// (note that __GNUC__ also implies clang, MinGW) -#elif defined(__GNUC__) - -// check to see if 'long long' is an alias for 'int64_t' -# if defined(_GLIBCXX_HAVE_INT64_T) && defined(_GLIBCXX_HAVE_INT64_T_LONG_LONG) -# include -typedef int64_t rcpp_long_long_type; -typedef uint64_t rcpp_ulong_long_type; -# define RCPP_HAS_LONG_LONG_TYPES - -// check to see if this is an older C++ compiler, but extensions are enabled -# elif defined(__GXX_EXPERIMENTAL_CXX0X__) || (defined(__clang__) && defined(__LP64__)) -# if defined(__LONG_LONG_MAX__) -__extension__ typedef long long int rcpp_long_long_type; -__extension__ typedef unsigned long long int rcpp_ulong_long_type; -# define RCPP_HAS_LONG_LONG_TYPES -# endif -# endif - -#endif - #endif diff --git a/inst/include/Rcpp/macros/dispatch.h b/inst/include/Rcpp/macros/dispatch.h index 111674995..06583ee62 100644 --- a/inst/include/Rcpp/macros/dispatch.h +++ b/inst/include/Rcpp/macros/dispatch.h @@ -3,7 +3,7 @@ // dispatch.h: Rcpp R/C++ interface class library -- macros for dispatch // // Copyright (C) 2012 - 2016 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2016 Dirk Eddelbuettel, Romain Francois, Artem Klevtsov and Nathan Russell +// Copyright (C) 2016 - 2025 Dirk Eddelbuettel, Romain Francois, Artem Klevtsov and Nathan Russell // // This file is part of Rcpp. // @@ -23,15 +23,13 @@ #ifndef Rcpp__macros__dispatch_h #define Rcpp__macros__dispatch_h -// The variadic macros below incorporate techniques presented by +// The variadic macros below incorporate techniques presented by // Stack Overflow user Richard Hansen in this answer // -// http://stackoverflow.com/a/11172679/1869097 +// http://stackoverflow.com/a/11172679/1869097 // // and are necessary to avoid the use of GNU compiler extensions. -#ifdef RCPP_USING_CXX11 - #define ___RCPP_HANDLE_CASE___(___RTYPE___, ___FUN___, ___RCPPTYPE___, ...) \ case ___RTYPE___: \ return ___FUN___(::Rcpp::___RCPPTYPE___<___RTYPE___>(RCPP_MACRO_FIRST(__VA_ARGS__)) \ @@ -77,32 +75,4 @@ #define RCPP_MACRO_SELECT_25TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, \ a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, ...) a25 -#else - -#define ___RCPP_HANDLE_CASE___(___RTYPE___, ___FUN___, ___OBJECT___, \ - ___RCPPTYPE___) \ - case ___RTYPE___: \ - return ___FUN___(::Rcpp::___RCPPTYPE___<___RTYPE___>(___OBJECT___)); - -#define ___RCPP_RETURN___(__FUN__, __SEXP__, __RCPPTYPE__) \ - SEXP __TMP__ = __SEXP__; \ - switch (TYPEOF(__TMP__)) { \ - ___RCPP_HANDLE_CASE___(INTSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - ___RCPP_HANDLE_CASE___(REALSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - ___RCPP_HANDLE_CASE___(RAWSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - ___RCPP_HANDLE_CASE___(LGLSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - ___RCPP_HANDLE_CASE___(CPLXSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - ___RCPP_HANDLE_CASE___(STRSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - ___RCPP_HANDLE_CASE___(VECSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - ___RCPP_HANDLE_CASE___(EXPRSXP, __FUN__, __TMP__, __RCPPTYPE__) \ - default: \ - throw std::range_error("Not a vector"); \ - } - -#define RCPP_RETURN_VECTOR(_FUN_, _SEXP_) \ - ___RCPP_RETURN___(_FUN_, _SEXP_, Vector) -#define RCPP_RETURN_MATRIX(_FUN_, _SEXP_) \ - ___RCPP_RETURN___(_FUN_, _SEXP_, Matrix) -#endif - #endif diff --git a/inst/include/Rcpp/macros/mask.h b/inst/include/Rcpp/macros/mask.h new file mode 100644 index 000000000..29bca519a --- /dev/null +++ b/inst/include/Rcpp/macros/mask.h @@ -0,0 +1,35 @@ +// mask.h: Rcpp R/C++ interface class library -- masking macros +// +// Copyright (C) 2025 Iñaki Ucar +// +// 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 . + +#ifndef Rcpp_macros_mask_h +#define Rcpp_macros_mask_h + +#ifndef RCPP_NO_MASK_RF_ERROR +#ifdef RCPP_MASK_RF_ERROR +#define Rf_error(...) \ + _Pragma("GCC warning \"Use of Rf_error() instead of Rcpp::stop(). Calls \ +to Rf_error() in C++ contexts are unsafe: consider using Rcpp::stop() instead, \ +or define RCPP_NO_MASK_RF_ERROR if this is a false positive. More info:\n\ + - https://github.com/RcppCore/Rcpp/issues/1247\n\ + - https://github.com/RcppCore/Rcpp/pull/1402\"") \ + Rf_error(__VA_ARGS__) +#endif +#endif + +#endif diff --git a/inst/include/Rcpp/module/Module_generated_Constructor.h b/inst/include/Rcpp/module/Module_generated_Constructor.h deleted file mode 100644 index 8d85aa7b4..000000000 --- a/inst/include/Rcpp/module/Module_generated_Constructor.h +++ /dev/null @@ -1,148 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Module_generated_Constructor.h: Rcpp R/C++ interface class library -- Rcpp modules -// -// Copyright (C) 2010 - 2013 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 . - -#ifndef Rcpp_Module_generated_Constructor_h -#define Rcpp_Module_generated_Constructor_h - -template -class Constructor_Base { -public: - virtual Class* get_new( SEXP* args, int nargs ) = 0 ; - virtual int nargs() = 0 ; - virtual void signature(std::string& s, const std::string& class_name) = 0 ; -} ; - -template -class Constructor_0 : public Constructor_Base{ -public: - virtual Class* get_new( SEXP* /*args*/, int /*nargs*/ ){ - return new Class() ; - } - virtual int nargs(){ return 0 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; -template -class Constructor_1 : public Constructor_Base{ - virtual Class* get_new( SEXP* args, int nargs ){ - return new Class( as(args[0]) ) ; - } - virtual int nargs(){ return 1 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; -template -class Constructor_2 : public Constructor_Base{ - virtual Class* get_new( SEXP* args, int nargs ){ - return new Class( - as(args[0]), - as(args[1]) - ) ; - } - virtual int nargs(){ return 2 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; -template -class Constructor_3 : public Constructor_Base{ - virtual Class* get_new( SEXP* args, int nargs ){ - return new Class( - as(args[0]), - as(args[1]), - as(args[2]) - ) ; - } - virtual int nargs(){ return 3 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; -template -class Constructor_4 : public Constructor_Base{ - virtual Class* get_new( SEXP* args, int nargs ){ - return new Class( - as(args[0]), - as(args[1]), - as(args[2]), - as(args[3]) - ) ; - } - virtual int nargs(){ return 4 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; -template -class Constructor_5 : public Constructor_Base{ - virtual Class* get_new( SEXP* args, int nargs ){ - return new Class( - as(args[0]), - as(args[1]), - as(args[2]), - as(args[3]), - as(args[4]) - ) ; - } - virtual int nargs(){ return 5 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; -template -class Constructor_6 : public Constructor_Base{ - virtual Class* get_new( SEXP* args, int nargs ){ - return new Class( - as(args[0]), - as(args[1]), - as(args[2]), - as(args[3]), - as(args[4]), - as(args[5]) - ) ; - } - virtual int nargs(){ return 6 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; -template -class Constructor_7 : public Constructor_Base{ - virtual Class* get_new( SEXP* args, int nargs ){ - return new Class( - as(args[0]), - as(args[1]), - as(args[2]), - as(args[3]), - as(args[4]), - as(args[5]), - as(args[6]) - ) ; - } - virtual int nargs(){ return 7 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -} ; - -#endif diff --git a/inst/include/Rcpp/module/Module_generated_CppFunction.h b/inst/include/Rcpp/module/Module_generated_CppFunction.h deleted file mode 100644 index 2393cb1ef..000000000 --- a/inst/include/Rcpp/module/Module_generated_CppFunction.h +++ /dev/null @@ -1,14411 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// Module_generated_CppFunction.h: -- generated helper code for Modules -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 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 . - -#ifndef Rcpp_Module_generated_CppFunction_h -#define Rcpp_Module_generated_CppFunction_h - -namespace Rcpp { - -template -class CppFunction0 : public CppFunction { - public: - CppFunction0(RESULT_TYPE (*fun)(void), const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - SEXP operator()(SEXP*) { - BEGIN_RCPP - return Rcpp::module_wrap(ptr_fun()); - END_RCPP - } - - inline int nargs() { return 0; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - RESULT_TYPE (*ptr_fun)(void); -}; - - -template <> -class CppFunction0 : public CppFunction { - public: - CppFunction0(void (*fun)(void), const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {}; - - SEXP operator()(SEXP*) { - BEGIN_RCPP - ptr_fun(); - END_RCPP - } - - inline int nargs() { return 0; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(void); -}; - - -template -class CppFunction_WithFormals0 : public CppFunction { - public: - CppFunction_WithFormals0(RESULT_TYPE (*fun)(void), Rcpp::List, const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - SEXP operator()(SEXP*) { - BEGIN_RCPP - return Rcpp::module_wrap(ptr_fun()); - END_RCPP - } - - inline int nargs() { return 0; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - RESULT_TYPE (*ptr_fun)(void); -}; - - -template <> -class CppFunction_WithFormals0 : public CppFunction { - public: - CppFunction_WithFormals0(void (*fun)(void), Rcpp::List, const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} ; - - SEXP operator()(SEXP*) { - BEGIN_RCPP - ptr_fun() ; - END_RCPP - } - - inline int nargs() { return 0; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(void) ; -}; - - -template class CppFunction1 : public CppFunction { - public: - - CppFunction1(RESULT_TYPE (*fun)(U0) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - return Rcpp::module_wrap(ptr_fun(x0)); - END_RCPP - } - - inline int nargs() { return 1; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0) ; -}; - -template -class CppFunction1 : public CppFunction { - public: - CppFunction1(void (*fun)(U0) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - ptr_fun(x0); - END_RCPP - } - - inline int nargs() { return 1; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0) ; -}; - - - -template -class CppFunction_WithFormals1 : public CppFunction { - public: - - CppFunction_WithFormals1(RESULT_TYPE (*fun)(U0) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - return Rcpp::module_wrap(ptr_fun(x0)); - END_RCPP - } - - inline int nargs() { return 1; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0); -}; - -template -class CppFunction_WithFormals1 : public CppFunction { - public: - CppFunction_WithFormals1(void (*fun)(U0), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - ptr_fun(x0); - END_RCPP - } - - inline int nargs() { return 1; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0); -}; - - -template class CppFunction2 : public CppFunction { - public: - - CppFunction2(RESULT_TYPE (*fun)(U0,U1) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - return Rcpp::module_wrap(ptr_fun(x0,x1)); - END_RCPP - } - - inline int nargs() { return 2; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1) ; -}; - -template -class CppFunction2 : public CppFunction { - public: - CppFunction2(void (*fun)(U0,U1) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - ptr_fun(x0,x1); - END_RCPP - } - - inline int nargs() { return 2; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1) ; -}; - - - -template -class CppFunction_WithFormals2 : public CppFunction { - public: - - CppFunction_WithFormals2(RESULT_TYPE (*fun)(U0,U1) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - return Rcpp::module_wrap(ptr_fun(x0,x1)); - END_RCPP - } - - inline int nargs() { return 2; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1); -}; - -template -class CppFunction_WithFormals2 : public CppFunction { - public: - CppFunction_WithFormals2(void (*fun)(U0,U1), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - ptr_fun(x0,x1); - END_RCPP - } - - inline int nargs() { return 2; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1); -}; - - -template class CppFunction3 : public CppFunction { - public: - - CppFunction3(RESULT_TYPE (*fun)(U0,U1,U2) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2)); - END_RCPP - } - - inline int nargs() { return 3; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2) ; -}; - -template -class CppFunction3 : public CppFunction { - public: - CppFunction3(void (*fun)(U0,U1,U2) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - ptr_fun(x0,x1,x2); - END_RCPP - } - - inline int nargs() { return 3; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2) ; -}; - - - -template -class CppFunction_WithFormals3 : public CppFunction { - public: - - CppFunction_WithFormals3(RESULT_TYPE (*fun)(U0,U1,U2) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2)); - END_RCPP - } - - inline int nargs() { return 3; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2); -}; - -template -class CppFunction_WithFormals3 : public CppFunction { - public: - CppFunction_WithFormals3(void (*fun)(U0,U1,U2), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - ptr_fun(x0,x1,x2); - END_RCPP - } - - inline int nargs() { return 3; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2); -}; - - -template class CppFunction4 : public CppFunction { - public: - - CppFunction4(RESULT_TYPE (*fun)(U0,U1,U2,U3) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3)); - END_RCPP - } - - inline int nargs() { return 4; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3) ; -}; - -template -class CppFunction4 : public CppFunction { - public: - CppFunction4(void (*fun)(U0,U1,U2,U3) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - ptr_fun(x0,x1,x2,x3); - END_RCPP - } - - inline int nargs() { return 4; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3) ; -}; - - - -template -class CppFunction_WithFormals4 : public CppFunction { - public: - - CppFunction_WithFormals4(RESULT_TYPE (*fun)(U0,U1,U2,U3) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3)); - END_RCPP - } - - inline int nargs() { return 4; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3); -}; - -template -class CppFunction_WithFormals4 : public CppFunction { - public: - CppFunction_WithFormals4(void (*fun)(U0,U1,U2,U3), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - ptr_fun(x0,x1,x2,x3); - END_RCPP - } - - inline int nargs() { return 4; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3); -}; - - -template class CppFunction5 : public CppFunction { - public: - - CppFunction5(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4)); - END_RCPP - } - - inline int nargs() { return 5; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4) ; -}; - -template -class CppFunction5 : public CppFunction { - public: - CppFunction5(void (*fun)(U0,U1,U2,U3,U4) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - ptr_fun(x0,x1,x2,x3,x4); - END_RCPP - } - - inline int nargs() { return 5; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4) ; -}; - - - -template -class CppFunction_WithFormals5 : public CppFunction { - public: - - CppFunction_WithFormals5(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4)); - END_RCPP - } - - inline int nargs() { return 5; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4); -}; - -template -class CppFunction_WithFormals5 : public CppFunction { - public: - CppFunction_WithFormals5(void (*fun)(U0,U1,U2,U3,U4), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - ptr_fun(x0,x1,x2,x3,x4); - END_RCPP - } - - inline int nargs() { return 5; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4); -}; - - -template class CppFunction6 : public CppFunction { - public: - - CppFunction6(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5)); - END_RCPP - } - - inline int nargs() { return 6; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5) ; -}; - -template -class CppFunction6 : public CppFunction { - public: - CppFunction6(void (*fun)(U0,U1,U2,U3,U4,U5) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - ptr_fun(x0,x1,x2,x3,x4,x5); - END_RCPP - } - - inline int nargs() { return 6; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5) ; -}; - - - -template -class CppFunction_WithFormals6 : public CppFunction { - public: - - CppFunction_WithFormals6(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5)); - END_RCPP - } - - inline int nargs() { return 6; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5); -}; - -template -class CppFunction_WithFormals6 : public CppFunction { - public: - CppFunction_WithFormals6(void (*fun)(U0,U1,U2,U3,U4,U5), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - ptr_fun(x0,x1,x2,x3,x4,x5); - END_RCPP - } - - inline int nargs() { return 6; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5); -}; - - -template class CppFunction7 : public CppFunction { - public: - - CppFunction7(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6)); - END_RCPP - } - - inline int nargs() { return 7; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6) ; -}; - -template -class CppFunction7 : public CppFunction { - public: - CppFunction7(void (*fun)(U0,U1,U2,U3,U4,U5,U6) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6); - END_RCPP - } - - inline int nargs() { return 7; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6) ; -}; - - - -template -class CppFunction_WithFormals7 : public CppFunction { - public: - - CppFunction_WithFormals7(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6)); - END_RCPP - } - - inline int nargs() { return 7; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6); -}; - -template -class CppFunction_WithFormals7 : public CppFunction { - public: - CppFunction_WithFormals7(void (*fun)(U0,U1,U2,U3,U4,U5,U6), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6); - END_RCPP - } - - inline int nargs() { return 7; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6); -}; - - -template class CppFunction8 : public CppFunction { - public: - - CppFunction8(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7)); - END_RCPP - } - - inline int nargs() { return 8; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7) ; -}; - -template -class CppFunction8 : public CppFunction { - public: - CppFunction8(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7); - END_RCPP - } - - inline int nargs() { return 8; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7) ; -}; - - - -template -class CppFunction_WithFormals8 : public CppFunction { - public: - - CppFunction_WithFormals8(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7)); - END_RCPP - } - - inline int nargs() { return 8; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7); -}; - -template -class CppFunction_WithFormals8 : public CppFunction { - public: - CppFunction_WithFormals8(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7); - END_RCPP - } - - inline int nargs() { return 8; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7); -}; - - -template class CppFunction9 : public CppFunction { - public: - - CppFunction9(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8)); - END_RCPP - } - - inline int nargs() { return 9; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8) ; -}; - -template -class CppFunction9 : public CppFunction { - public: - CppFunction9(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8); - END_RCPP - } - - inline int nargs() { return 9; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8) ; -}; - - - -template -class CppFunction_WithFormals9 : public CppFunction { - public: - - CppFunction_WithFormals9(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8)); - END_RCPP - } - - inline int nargs() { return 9; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8); -}; - -template -class CppFunction_WithFormals9 : public CppFunction { - public: - CppFunction_WithFormals9(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8); - END_RCPP - } - - inline int nargs() { return 9; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8); -}; - - -template class CppFunction10 : public CppFunction { - public: - - CppFunction10(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9)); - END_RCPP - } - - inline int nargs() { return 10; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9) ; -}; - -template -class CppFunction10 : public CppFunction { - public: - CppFunction10(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9); - END_RCPP - } - - inline int nargs() { return 10; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9) ; -}; - - - -template -class CppFunction_WithFormals10 : public CppFunction { - public: - - CppFunction_WithFormals10(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9)); - END_RCPP - } - - inline int nargs() { return 10; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9); -}; - -template -class CppFunction_WithFormals10 : public CppFunction { - public: - CppFunction_WithFormals10(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9); - END_RCPP - } - - inline int nargs() { return 10; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9); -}; - - -template class CppFunction11 : public CppFunction { - public: - - CppFunction11(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10)); - END_RCPP - } - - inline int nargs() { return 11; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10) ; -}; - -template -class CppFunction11 : public CppFunction { - public: - CppFunction11(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10); - END_RCPP - } - - inline int nargs() { return 11; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10) ; -}; - - - -template -class CppFunction_WithFormals11 : public CppFunction { - public: - - CppFunction_WithFormals11(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10)); - END_RCPP - } - - inline int nargs() { return 11; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10); -}; - -template -class CppFunction_WithFormals11 : public CppFunction { - public: - CppFunction_WithFormals11(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10); - END_RCPP - } - - inline int nargs() { return 11; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10); -}; - - -template class CppFunction12 : public CppFunction { - public: - - CppFunction12(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11)); - END_RCPP - } - - inline int nargs() { return 12; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11) ; -}; - -template -class CppFunction12 : public CppFunction { - public: - CppFunction12(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11); - END_RCPP - } - - inline int nargs() { return 12; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11) ; -}; - - - -template -class CppFunction_WithFormals12 : public CppFunction { - public: - - CppFunction_WithFormals12(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11)); - END_RCPP - } - - inline int nargs() { return 12; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11); -}; - -template -class CppFunction_WithFormals12 : public CppFunction { - public: - CppFunction_WithFormals12(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11); - END_RCPP - } - - inline int nargs() { return 12; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11); -}; - - -template class CppFunction13 : public CppFunction { - public: - - CppFunction13(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)); - END_RCPP - } - - inline int nargs() { return 13; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12) ; -}; - -template -class CppFunction13 : public CppFunction { - public: - CppFunction13(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12); - END_RCPP - } - - inline int nargs() { return 13; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12) ; -}; - - - -template -class CppFunction_WithFormals13 : public CppFunction { - public: - - CppFunction_WithFormals13(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12)); - END_RCPP - } - - inline int nargs() { return 13; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12); -}; - -template -class CppFunction_WithFormals13 : public CppFunction { - public: - CppFunction_WithFormals13(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12); - END_RCPP - } - - inline int nargs() { return 13; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12); -}; - - -template class CppFunction14 : public CppFunction { - public: - - CppFunction14(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13)); - END_RCPP - } - - inline int nargs() { return 14; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13) ; -}; - -template -class CppFunction14 : public CppFunction { - public: - CppFunction14(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13); - END_RCPP - } - - inline int nargs() { return 14; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13) ; -}; - - - -template -class CppFunction_WithFormals14 : public CppFunction { - public: - - CppFunction_WithFormals14(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13)); - END_RCPP - } - - inline int nargs() { return 14; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13); -}; - -template -class CppFunction_WithFormals14 : public CppFunction { - public: - CppFunction_WithFormals14(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13); - END_RCPP - } - - inline int nargs() { return 14; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13); -}; - - -template class CppFunction15 : public CppFunction { - public: - - CppFunction15(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14)); - END_RCPP - } - - inline int nargs() { return 15; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14) ; -}; - -template -class CppFunction15 : public CppFunction { - public: - CppFunction15(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14); - END_RCPP - } - - inline int nargs() { return 15; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14) ; -}; - - - -template -class CppFunction_WithFormals15 : public CppFunction { - public: - - CppFunction_WithFormals15(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14)); - END_RCPP - } - - inline int nargs() { return 15; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14); -}; - -template -class CppFunction_WithFormals15 : public CppFunction { - public: - CppFunction_WithFormals15(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14); - END_RCPP - } - - inline int nargs() { return 15; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14); -}; - - -template class CppFunction16 : public CppFunction { - public: - - CppFunction16(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15)); - END_RCPP - } - - inline int nargs() { return 16; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15) ; -}; - -template -class CppFunction16 : public CppFunction { - public: - CppFunction16(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15); - END_RCPP - } - - inline int nargs() { return 16; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15) ; -}; - - - -template -class CppFunction_WithFormals16 : public CppFunction { - public: - - CppFunction_WithFormals16(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15)); - END_RCPP - } - - inline int nargs() { return 16; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15); -}; - -template -class CppFunction_WithFormals16 : public CppFunction { - public: - CppFunction_WithFormals16(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15); - END_RCPP - } - - inline int nargs() { return 16; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15); -}; - - -template class CppFunction17 : public CppFunction { - public: - - CppFunction17(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16)); - END_RCPP - } - - inline int nargs() { return 17; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16) ; -}; - -template -class CppFunction17 : public CppFunction { - public: - CppFunction17(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16); - END_RCPP - } - - inline int nargs() { return 17; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16) ; -}; - - - -template -class CppFunction_WithFormals17 : public CppFunction { - public: - - CppFunction_WithFormals17(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16)); - END_RCPP - } - - inline int nargs() { return 17; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16); -}; - -template -class CppFunction_WithFormals17 : public CppFunction { - public: - CppFunction_WithFormals17(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16); - END_RCPP - } - - inline int nargs() { return 17; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16); -}; - - -template class CppFunction18 : public CppFunction { - public: - - CppFunction18(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17)); - END_RCPP - } - - inline int nargs() { return 18; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17) ; -}; - -template -class CppFunction18 : public CppFunction { - public: - CppFunction18(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17); - END_RCPP - } - - inline int nargs() { return 18; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17) ; -}; - - - -template -class CppFunction_WithFormals18 : public CppFunction { - public: - - CppFunction_WithFormals18(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17)); - END_RCPP - } - - inline int nargs() { return 18; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17); -}; - -template -class CppFunction_WithFormals18 : public CppFunction { - public: - CppFunction_WithFormals18(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17); - END_RCPP - } - - inline int nargs() { return 18; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17); -}; - - -template class CppFunction19 : public CppFunction { - public: - - CppFunction19(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18)); - END_RCPP - } - - inline int nargs() { return 19; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18) ; -}; - -template -class CppFunction19 : public CppFunction { - public: - CppFunction19(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18); - END_RCPP - } - - inline int nargs() { return 19; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18) ; -}; - - - -template -class CppFunction_WithFormals19 : public CppFunction { - public: - - CppFunction_WithFormals19(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18)); - END_RCPP - } - - inline int nargs() { return 19; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18); -}; - -template -class CppFunction_WithFormals19 : public CppFunction { - public: - CppFunction_WithFormals19(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18); - END_RCPP - } - - inline int nargs() { return 19; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18); -}; - - -template class CppFunction20 : public CppFunction { - public: - - CppFunction20(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19)); - END_RCPP - } - - inline int nargs() { return 20; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19) ; -}; - -template -class CppFunction20 : public CppFunction { - public: - CppFunction20(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19); - END_RCPP - } - - inline int nargs() { return 20; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19) ; -}; - - - -template -class CppFunction_WithFormals20 : public CppFunction { - public: - - CppFunction_WithFormals20(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19)); - END_RCPP - } - - inline int nargs() { return 20; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19); -}; - -template -class CppFunction_WithFormals20 : public CppFunction { - public: - CppFunction_WithFormals20(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19); - END_RCPP - } - - inline int nargs() { return 20; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19); -}; - - -template class CppFunction21 : public CppFunction { - public: - - CppFunction21(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20)); - END_RCPP - } - - inline int nargs() { return 21; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20) ; -}; - -template -class CppFunction21 : public CppFunction { - public: - CppFunction21(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20); - END_RCPP - } - - inline int nargs() { return 21; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20) ; -}; - - - -template -class CppFunction_WithFormals21 : public CppFunction { - public: - - CppFunction_WithFormals21(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20)); - END_RCPP - } - - inline int nargs() { return 21; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20); -}; - -template -class CppFunction_WithFormals21 : public CppFunction { - public: - CppFunction_WithFormals21(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20); - END_RCPP - } - - inline int nargs() { return 21; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20); -}; - - -template class CppFunction22 : public CppFunction { - public: - - CppFunction22(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21)); - END_RCPP - } - - inline int nargs() { return 22; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21) ; -}; - -template -class CppFunction22 : public CppFunction { - public: - CppFunction22(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21); - END_RCPP - } - - inline int nargs() { return 22; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21) ; -}; - - - -template -class CppFunction_WithFormals22 : public CppFunction { - public: - - CppFunction_WithFormals22(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21)); - END_RCPP - } - - inline int nargs() { return 22; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21); -}; - -template -class CppFunction_WithFormals22 : public CppFunction { - public: - CppFunction_WithFormals22(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21); - END_RCPP - } - - inline int nargs() { return 22; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21); -}; - - -template class CppFunction23 : public CppFunction { - public: - - CppFunction23(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22)); - END_RCPP - } - - inline int nargs() { return 23; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22) ; -}; - -template -class CppFunction23 : public CppFunction { - public: - CppFunction23(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22); - END_RCPP - } - - inline int nargs() { return 23; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22) ; -}; - - - -template -class CppFunction_WithFormals23 : public CppFunction { - public: - - CppFunction_WithFormals23(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22)); - END_RCPP - } - - inline int nargs() { return 23; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22); -}; - -template -class CppFunction_WithFormals23 : public CppFunction { - public: - CppFunction_WithFormals23(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22); - END_RCPP - } - - inline int nargs() { return 23; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22); -}; - - -template class CppFunction24 : public CppFunction { - public: - - CppFunction24(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23)); - END_RCPP - } - - inline int nargs() { return 24; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23) ; -}; - -template -class CppFunction24 : public CppFunction { - public: - CppFunction24(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23); - END_RCPP - } - - inline int nargs() { return 24; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23) ; -}; - - - -template -class CppFunction_WithFormals24 : public CppFunction { - public: - - CppFunction_WithFormals24(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23)); - END_RCPP - } - - inline int nargs() { return 24; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23); -}; - -template -class CppFunction_WithFormals24 : public CppFunction { - public: - CppFunction_WithFormals24(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23); - END_RCPP - } - - inline int nargs() { return 24; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23); -}; - - -template class CppFunction25 : public CppFunction { - public: - - CppFunction25(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24)); - END_RCPP - } - - inline int nargs() { return 25; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24) ; -}; - -template -class CppFunction25 : public CppFunction { - public: - CppFunction25(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24); - END_RCPP - } - - inline int nargs() { return 25; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24) ; -}; - - - -template -class CppFunction_WithFormals25 : public CppFunction { - public: - - CppFunction_WithFormals25(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24)); - END_RCPP - } - - inline int nargs() { return 25; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24); -}; - -template -class CppFunction_WithFormals25 : public CppFunction { - public: - CppFunction_WithFormals25(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24); - END_RCPP - } - - inline int nargs() { return 25; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24); -}; - - -template class CppFunction26 : public CppFunction { - public: - - CppFunction26(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25)); - END_RCPP - } - - inline int nargs() { return 26; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25) ; -}; - -template -class CppFunction26 : public CppFunction { - public: - CppFunction26(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25); - END_RCPP - } - - inline int nargs() { return 26; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25) ; -}; - - - -template -class CppFunction_WithFormals26 : public CppFunction { - public: - - CppFunction_WithFormals26(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25)); - END_RCPP - } - - inline int nargs() { return 26; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25); -}; - -template -class CppFunction_WithFormals26 : public CppFunction { - public: - CppFunction_WithFormals26(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25); - END_RCPP - } - - inline int nargs() { return 26; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25); -}; - - -template class CppFunction27 : public CppFunction { - public: - - CppFunction27(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26)); - END_RCPP - } - - inline int nargs() { return 27; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26) ; -}; - -template -class CppFunction27 : public CppFunction { - public: - CppFunction27(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26); - END_RCPP - } - - inline int nargs() { return 27; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26) ; -}; - - - -template -class CppFunction_WithFormals27 : public CppFunction { - public: - - CppFunction_WithFormals27(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26)); - END_RCPP - } - - inline int nargs() { return 27; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26); -}; - -template -class CppFunction_WithFormals27 : public CppFunction { - public: - CppFunction_WithFormals27(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26); - END_RCPP - } - - inline int nargs() { return 27; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26); -}; - - -template class CppFunction28 : public CppFunction { - public: - - CppFunction28(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27)); - END_RCPP - } - - inline int nargs() { return 28; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27) ; -}; - -template -class CppFunction28 : public CppFunction { - public: - CppFunction28(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27); - END_RCPP - } - - inline int nargs() { return 28; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27) ; -}; - - - -template -class CppFunction_WithFormals28 : public CppFunction { - public: - - CppFunction_WithFormals28(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27)); - END_RCPP - } - - inline int nargs() { return 28; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27); -}; - -template -class CppFunction_WithFormals28 : public CppFunction { - public: - CppFunction_WithFormals28(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27); - END_RCPP - } - - inline int nargs() { return 28; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27); -}; - - -template class CppFunction29 : public CppFunction { - public: - - CppFunction29(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28)); - END_RCPP - } - - inline int nargs() { return 29; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28) ; -}; - -template -class CppFunction29 : public CppFunction { - public: - CppFunction29(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28); - END_RCPP - } - - inline int nargs() { return 29; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28) ; -}; - - - -template -class CppFunction_WithFormals29 : public CppFunction { - public: - - CppFunction_WithFormals29(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28)); - END_RCPP - } - - inline int nargs() { return 29; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28); -}; - -template -class CppFunction_WithFormals29 : public CppFunction { - public: - CppFunction_WithFormals29(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28); - END_RCPP - } - - inline int nargs() { return 29; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28); -}; - - -template class CppFunction30 : public CppFunction { - public: - - CppFunction30(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29)); - END_RCPP - } - - inline int nargs() { return 30; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29) ; -}; - -template -class CppFunction30 : public CppFunction { - public: - CppFunction30(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29); - END_RCPP - } - - inline int nargs() { return 30; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29) ; -}; - - - -template -class CppFunction_WithFormals30 : public CppFunction { - public: - - CppFunction_WithFormals30(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29)); - END_RCPP - } - - inline int nargs() { return 30; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29); -}; - -template -class CppFunction_WithFormals30 : public CppFunction { - public: - CppFunction_WithFormals30(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29); - END_RCPP - } - - inline int nargs() { return 30; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29); -}; - - -template class CppFunction31 : public CppFunction { - public: - - CppFunction31(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30)); - END_RCPP - } - - inline int nargs() { return 31; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30) ; -}; - -template -class CppFunction31 : public CppFunction { - public: - CppFunction31(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30); - END_RCPP - } - - inline int nargs() { return 31; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30) ; -}; - - - -template -class CppFunction_WithFormals31 : public CppFunction { - public: - - CppFunction_WithFormals31(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30)); - END_RCPP - } - - inline int nargs() { return 31; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30); -}; - -template -class CppFunction_WithFormals31 : public CppFunction { - public: - CppFunction_WithFormals31(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30); - END_RCPP - } - - inline int nargs() { return 31; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30); -}; - - -template class CppFunction32 : public CppFunction { - public: - - CppFunction32(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31)); - END_RCPP - } - - inline int nargs() { return 32; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31) ; -}; - -template -class CppFunction32 : public CppFunction { - public: - CppFunction32(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31); - END_RCPP - } - - inline int nargs() { return 32; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31) ; -}; - - - -template -class CppFunction_WithFormals32 : public CppFunction { - public: - - CppFunction_WithFormals32(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31)); - END_RCPP - } - - inline int nargs() { return 32; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31); -}; - -template -class CppFunction_WithFormals32 : public CppFunction { - public: - CppFunction_WithFormals32(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31); - END_RCPP - } - - inline int nargs() { return 32; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31); -}; - - -template class CppFunction33 : public CppFunction { - public: - - CppFunction33(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32)); - END_RCPP - } - - inline int nargs() { return 33; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32) ; -}; - -template -class CppFunction33 : public CppFunction { - public: - CppFunction33(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32); - END_RCPP - } - - inline int nargs() { return 33; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32) ; -}; - - - -template -class CppFunction_WithFormals33 : public CppFunction { - public: - - CppFunction_WithFormals33(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32)); - END_RCPP - } - - inline int nargs() { return 33; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32); -}; - -template -class CppFunction_WithFormals33 : public CppFunction { - public: - CppFunction_WithFormals33(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32); - END_RCPP - } - - inline int nargs() { return 33; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32); -}; - - -template class CppFunction34 : public CppFunction { - public: - - CppFunction34(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33)); - END_RCPP - } - - inline int nargs() { return 34; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33) ; -}; - -template -class CppFunction34 : public CppFunction { - public: - CppFunction34(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33); - END_RCPP - } - - inline int nargs() { return 34; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33) ; -}; - - - -template -class CppFunction_WithFormals34 : public CppFunction { - public: - - CppFunction_WithFormals34(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33)); - END_RCPP - } - - inline int nargs() { return 34; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33); -}; - -template -class CppFunction_WithFormals34 : public CppFunction { - public: - CppFunction_WithFormals34(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33); - END_RCPP - } - - inline int nargs() { return 34; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33); -}; - - -template class CppFunction35 : public CppFunction { - public: - - CppFunction35(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34)); - END_RCPP - } - - inline int nargs() { return 35; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34) ; -}; - -template -class CppFunction35 : public CppFunction { - public: - CppFunction35(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34); - END_RCPP - } - - inline int nargs() { return 35; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34) ; -}; - - - -template -class CppFunction_WithFormals35 : public CppFunction { - public: - - CppFunction_WithFormals35(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34)); - END_RCPP - } - - inline int nargs() { return 35; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34); -}; - -template -class CppFunction_WithFormals35 : public CppFunction { - public: - CppFunction_WithFormals35(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34); - END_RCPP - } - - inline int nargs() { return 35; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34); -}; - - -template class CppFunction36 : public CppFunction { - public: - - CppFunction36(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35)); - END_RCPP - } - - inline int nargs() { return 36; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35) ; -}; - -template -class CppFunction36 : public CppFunction { - public: - CppFunction36(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35); - END_RCPP - } - - inline int nargs() { return 36; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35) ; -}; - - - -template -class CppFunction_WithFormals36 : public CppFunction { - public: - - CppFunction_WithFormals36(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35)); - END_RCPP - } - - inline int nargs() { return 36; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35); -}; - -template -class CppFunction_WithFormals36 : public CppFunction { - public: - CppFunction_WithFormals36(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35); - END_RCPP - } - - inline int nargs() { return 36; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35); -}; - - -template class CppFunction37 : public CppFunction { - public: - - CppFunction37(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36)); - END_RCPP - } - - inline int nargs() { return 37; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36) ; -}; - -template -class CppFunction37 : public CppFunction { - public: - CppFunction37(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36); - END_RCPP - } - - inline int nargs() { return 37; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36) ; -}; - - - -template -class CppFunction_WithFormals37 : public CppFunction { - public: - - CppFunction_WithFormals37(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36)); - END_RCPP - } - - inline int nargs() { return 37; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36); -}; - -template -class CppFunction_WithFormals37 : public CppFunction { - public: - CppFunction_WithFormals37(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36); - END_RCPP - } - - inline int nargs() { return 37; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36); -}; - - -template class CppFunction38 : public CppFunction { - public: - - CppFunction38(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37)); - END_RCPP - } - - inline int nargs() { return 38; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37) ; -}; - -template -class CppFunction38 : public CppFunction { - public: - CppFunction38(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37); - END_RCPP - } - - inline int nargs() { return 38; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37) ; -}; - - - -template -class CppFunction_WithFormals38 : public CppFunction { - public: - - CppFunction_WithFormals38(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37)); - END_RCPP - } - - inline int nargs() { return 38; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37); -}; - -template -class CppFunction_WithFormals38 : public CppFunction { - public: - CppFunction_WithFormals38(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37); - END_RCPP - } - - inline int nargs() { return 38; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37); -}; - - -template class CppFunction39 : public CppFunction { - public: - - CppFunction39(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38)); - END_RCPP - } - - inline int nargs() { return 39; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38) ; -}; - -template -class CppFunction39 : public CppFunction { - public: - CppFunction39(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38); - END_RCPP - } - - inline int nargs() { return 39; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38) ; -}; - - - -template -class CppFunction_WithFormals39 : public CppFunction { - public: - - CppFunction_WithFormals39(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38)); - END_RCPP - } - - inline int nargs() { return 39; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38); -}; - -template -class CppFunction_WithFormals39 : public CppFunction { - public: - CppFunction_WithFormals39(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38); - END_RCPP - } - - inline int nargs() { return 39; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38); -}; - - -template class CppFunction40 : public CppFunction { - public: - - CppFunction40(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39)); - END_RCPP - } - - inline int nargs() { return 40; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39) ; -}; - -template -class CppFunction40 : public CppFunction { - public: - CppFunction40(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39); - END_RCPP - } - - inline int nargs() { return 40; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39) ; -}; - - - -template -class CppFunction_WithFormals40 : public CppFunction { - public: - - CppFunction_WithFormals40(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39)); - END_RCPP - } - - inline int nargs() { return 40; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39); -}; - -template -class CppFunction_WithFormals40 : public CppFunction { - public: - CppFunction_WithFormals40(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39); - END_RCPP - } - - inline int nargs() { return 40; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39); -}; - - -template class CppFunction41 : public CppFunction { - public: - - CppFunction41(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40)); - END_RCPP - } - - inline int nargs() { return 41; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40) ; -}; - -template -class CppFunction41 : public CppFunction { - public: - CppFunction41(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40); - END_RCPP - } - - inline int nargs() { return 41; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40) ; -}; - - - -template -class CppFunction_WithFormals41 : public CppFunction { - public: - - CppFunction_WithFormals41(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40)); - END_RCPP - } - - inline int nargs() { return 41; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40); -}; - -template -class CppFunction_WithFormals41 : public CppFunction { - public: - CppFunction_WithFormals41(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40); - END_RCPP - } - - inline int nargs() { return 41; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40); -}; - - -template class CppFunction42 : public CppFunction { - public: - - CppFunction42(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41)); - END_RCPP - } - - inline int nargs() { return 42; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41) ; -}; - -template -class CppFunction42 : public CppFunction { - public: - CppFunction42(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41); - END_RCPP - } - - inline int nargs() { return 42; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41) ; -}; - - - -template -class CppFunction_WithFormals42 : public CppFunction { - public: - - CppFunction_WithFormals42(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41)); - END_RCPP - } - - inline int nargs() { return 42; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41); -}; - -template -class CppFunction_WithFormals42 : public CppFunction { - public: - CppFunction_WithFormals42(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41); - END_RCPP - } - - inline int nargs() { return 42; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41); -}; - - -template class CppFunction43 : public CppFunction { - public: - - CppFunction43(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42)); - END_RCPP - } - - inline int nargs() { return 43; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42) ; -}; - -template -class CppFunction43 : public CppFunction { - public: - CppFunction43(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42); - END_RCPP - } - - inline int nargs() { return 43; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42) ; -}; - - - -template -class CppFunction_WithFormals43 : public CppFunction { - public: - - CppFunction_WithFormals43(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42)); - END_RCPP - } - - inline int nargs() { return 43; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42); -}; - -template -class CppFunction_WithFormals43 : public CppFunction { - public: - CppFunction_WithFormals43(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42); - END_RCPP - } - - inline int nargs() { return 43; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42); -}; - - -template class CppFunction44 : public CppFunction { - public: - - CppFunction44(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43)); - END_RCPP - } - - inline int nargs() { return 44; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43) ; -}; - -template -class CppFunction44 : public CppFunction { - public: - CppFunction44(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43); - END_RCPP - } - - inline int nargs() { return 44; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43) ; -}; - - - -template -class CppFunction_WithFormals44 : public CppFunction { - public: - - CppFunction_WithFormals44(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43)); - END_RCPP - } - - inline int nargs() { return 44; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43); -}; - -template -class CppFunction_WithFormals44 : public CppFunction { - public: - CppFunction_WithFormals44(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43); - END_RCPP - } - - inline int nargs() { return 44; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43); -}; - - -template class CppFunction45 : public CppFunction { - public: - - CppFunction45(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44)); - END_RCPP - } - - inline int nargs() { return 45; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44) ; -}; - -template -class CppFunction45 : public CppFunction { - public: - CppFunction45(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44); - END_RCPP - } - - inline int nargs() { return 45; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44) ; -}; - - - -template -class CppFunction_WithFormals45 : public CppFunction { - public: - - CppFunction_WithFormals45(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44)); - END_RCPP - } - - inline int nargs() { return 45; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44); -}; - -template -class CppFunction_WithFormals45 : public CppFunction { - public: - CppFunction_WithFormals45(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44); - END_RCPP - } - - inline int nargs() { return 45; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44); -}; - - -template class CppFunction46 : public CppFunction { - public: - - CppFunction46(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45)); - END_RCPP - } - - inline int nargs() { return 46; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45) ; -}; - -template -class CppFunction46 : public CppFunction { - public: - CppFunction46(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45); - END_RCPP - } - - inline int nargs() { return 46; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45) ; -}; - - - -template -class CppFunction_WithFormals46 : public CppFunction { - public: - - CppFunction_WithFormals46(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45)); - END_RCPP - } - - inline int nargs() { return 46; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45); -}; - -template -class CppFunction_WithFormals46 : public CppFunction { - public: - CppFunction_WithFormals46(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45); - END_RCPP - } - - inline int nargs() { return 46; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45); -}; - - -template class CppFunction47 : public CppFunction { - public: - - CppFunction47(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46)); - END_RCPP - } - - inline int nargs() { return 47; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46) ; -}; - -template -class CppFunction47 : public CppFunction { - public: - CppFunction47(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46); - END_RCPP - } - - inline int nargs() { return 47; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46) ; -}; - - - -template -class CppFunction_WithFormals47 : public CppFunction { - public: - - CppFunction_WithFormals47(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46)); - END_RCPP - } - - inline int nargs() { return 47; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46); -}; - -template -class CppFunction_WithFormals47 : public CppFunction { - public: - CppFunction_WithFormals47(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46); - END_RCPP - } - - inline int nargs() { return 47; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46); -}; - - -template class CppFunction48 : public CppFunction { - public: - - CppFunction48(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47)); - END_RCPP - } - - inline int nargs() { return 48; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47) ; -}; - -template -class CppFunction48 : public CppFunction { - public: - CppFunction48(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47); - END_RCPP - } - - inline int nargs() { return 48; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47) ; -}; - - - -template -class CppFunction_WithFormals48 : public CppFunction { - public: - - CppFunction_WithFormals48(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47)); - END_RCPP - } - - inline int nargs() { return 48; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47); -}; - -template -class CppFunction_WithFormals48 : public CppFunction { - public: - CppFunction_WithFormals48(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47); - END_RCPP - } - - inline int nargs() { return 48; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47); -}; - - -template class CppFunction49 : public CppFunction { - public: - - CppFunction49(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48)); - END_RCPP - } - - inline int nargs() { return 49; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48) ; -}; - -template -class CppFunction49 : public CppFunction { - public: - CppFunction49(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48); - END_RCPP - } - - inline int nargs() { return 49; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48) ; -}; - - - -template -class CppFunction_WithFormals49 : public CppFunction { - public: - - CppFunction_WithFormals49(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48)); - END_RCPP - } - - inline int nargs() { return 49; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48); -}; - -template -class CppFunction_WithFormals49 : public CppFunction { - public: - CppFunction_WithFormals49(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48); - END_RCPP - } - - inline int nargs() { return 49; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48); -}; - - -template class CppFunction50 : public CppFunction { - public: - - CppFunction50(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49)); - END_RCPP - } - - inline int nargs() { return 50; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49) ; -}; - -template -class CppFunction50 : public CppFunction { - public: - CppFunction50(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49); - END_RCPP - } - - inline int nargs() { return 50; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49) ; -}; - - - -template -class CppFunction_WithFormals50 : public CppFunction { - public: - - CppFunction_WithFormals50(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49)); - END_RCPP - } - - inline int nargs() { return 50; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49); -}; - -template -class CppFunction_WithFormals50 : public CppFunction { - public: - CppFunction_WithFormals50(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49); - END_RCPP - } - - inline int nargs() { return 50; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49); -}; - - -template class CppFunction51 : public CppFunction { - public: - - CppFunction51(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50)); - END_RCPP - } - - inline int nargs() { return 51; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50) ; -}; - -template -class CppFunction51 : public CppFunction { - public: - CppFunction51(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50); - END_RCPP - } - - inline int nargs() { return 51; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50) ; -}; - - - -template -class CppFunction_WithFormals51 : public CppFunction { - public: - - CppFunction_WithFormals51(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50)); - END_RCPP - } - - inline int nargs() { return 51; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50); -}; - -template -class CppFunction_WithFormals51 : public CppFunction { - public: - CppFunction_WithFormals51(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50); - END_RCPP - } - - inline int nargs() { return 51; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50); -}; - - -template class CppFunction52 : public CppFunction { - public: - - CppFunction52(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51)); - END_RCPP - } - - inline int nargs() { return 52; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51) ; -}; - -template -class CppFunction52 : public CppFunction { - public: - CppFunction52(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51); - END_RCPP - } - - inline int nargs() { return 52; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51) ; -}; - - - -template -class CppFunction_WithFormals52 : public CppFunction { - public: - - CppFunction_WithFormals52(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51)); - END_RCPP - } - - inline int nargs() { return 52; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51); -}; - -template -class CppFunction_WithFormals52 : public CppFunction { - public: - CppFunction_WithFormals52(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51); - END_RCPP - } - - inline int nargs() { return 52; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51); -}; - - -template class CppFunction53 : public CppFunction { - public: - - CppFunction53(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52)); - END_RCPP - } - - inline int nargs() { return 53; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52) ; -}; - -template -class CppFunction53 : public CppFunction { - public: - CppFunction53(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52); - END_RCPP - } - - inline int nargs() { return 53; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52) ; -}; - - - -template -class CppFunction_WithFormals53 : public CppFunction { - public: - - CppFunction_WithFormals53(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52)); - END_RCPP - } - - inline int nargs() { return 53; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52); -}; - -template -class CppFunction_WithFormals53 : public CppFunction { - public: - CppFunction_WithFormals53(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52); - END_RCPP - } - - inline int nargs() { return 53; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52); -}; - - -template class CppFunction54 : public CppFunction { - public: - - CppFunction54(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53)); - END_RCPP - } - - inline int nargs() { return 54; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53) ; -}; - -template -class CppFunction54 : public CppFunction { - public: - CppFunction54(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53); - END_RCPP - } - - inline int nargs() { return 54; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53) ; -}; - - - -template -class CppFunction_WithFormals54 : public CppFunction { - public: - - CppFunction_WithFormals54(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53)); - END_RCPP - } - - inline int nargs() { return 54; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53); -}; - -template -class CppFunction_WithFormals54 : public CppFunction { - public: - CppFunction_WithFormals54(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53); - END_RCPP - } - - inline int nargs() { return 54; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53); -}; - - -template class CppFunction55 : public CppFunction { - public: - - CppFunction55(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54)); - END_RCPP - } - - inline int nargs() { return 55; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54) ; -}; - -template -class CppFunction55 : public CppFunction { - public: - CppFunction55(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54); - END_RCPP - } - - inline int nargs() { return 55; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54) ; -}; - - - -template -class CppFunction_WithFormals55 : public CppFunction { - public: - - CppFunction_WithFormals55(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54)); - END_RCPP - } - - inline int nargs() { return 55; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54); -}; - -template -class CppFunction_WithFormals55 : public CppFunction { - public: - CppFunction_WithFormals55(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54); - END_RCPP - } - - inline int nargs() { return 55; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54); -}; - - -template class CppFunction56 : public CppFunction { - public: - - CppFunction56(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55)); - END_RCPP - } - - inline int nargs() { return 56; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55) ; -}; - -template -class CppFunction56 : public CppFunction { - public: - CppFunction56(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55); - END_RCPP - } - - inline int nargs() { return 56; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55) ; -}; - - - -template -class CppFunction_WithFormals56 : public CppFunction { - public: - - CppFunction_WithFormals56(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55)); - END_RCPP - } - - inline int nargs() { return 56; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55); -}; - -template -class CppFunction_WithFormals56 : public CppFunction { - public: - CppFunction_WithFormals56(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55); - END_RCPP - } - - inline int nargs() { return 56; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55); -}; - - -template class CppFunction57 : public CppFunction { - public: - - CppFunction57(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56)); - END_RCPP - } - - inline int nargs() { return 57; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56) ; -}; - -template -class CppFunction57 : public CppFunction { - public: - CppFunction57(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56); - END_RCPP - } - - inline int nargs() { return 57; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56) ; -}; - - - -template -class CppFunction_WithFormals57 : public CppFunction { - public: - - CppFunction_WithFormals57(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56)); - END_RCPP - } - - inline int nargs() { return 57; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56); -}; - -template -class CppFunction_WithFormals57 : public CppFunction { - public: - CppFunction_WithFormals57(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56); - END_RCPP - } - - inline int nargs() { return 57; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56); -}; - - -template class CppFunction58 : public CppFunction { - public: - - CppFunction58(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57)); - END_RCPP - } - - inline int nargs() { return 58; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57) ; -}; - -template -class CppFunction58 : public CppFunction { - public: - CppFunction58(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57); - END_RCPP - } - - inline int nargs() { return 58; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57) ; -}; - - - -template -class CppFunction_WithFormals58 : public CppFunction { - public: - - CppFunction_WithFormals58(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57)); - END_RCPP - } - - inline int nargs() { return 58; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57); -}; - -template -class CppFunction_WithFormals58 : public CppFunction { - public: - CppFunction_WithFormals58(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57); - END_RCPP - } - - inline int nargs() { return 58; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57); -}; - - -template class CppFunction59 : public CppFunction { - public: - - CppFunction59(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58)); - END_RCPP - } - - inline int nargs() { return 59; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58) ; -}; - -template -class CppFunction59 : public CppFunction { - public: - CppFunction59(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58); - END_RCPP - } - - inline int nargs() { return 59; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58) ; -}; - - - -template -class CppFunction_WithFormals59 : public CppFunction { - public: - - CppFunction_WithFormals59(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58)); - END_RCPP - } - - inline int nargs() { return 59; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58); -}; - -template -class CppFunction_WithFormals59 : public CppFunction { - public: - CppFunction_WithFormals59(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58); - END_RCPP - } - - inline int nargs() { return 59; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58); -}; - - -template class CppFunction60 : public CppFunction { - public: - - CppFunction60(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59)); - END_RCPP - } - - inline int nargs() { return 60; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59) ; -}; - -template -class CppFunction60 : public CppFunction { - public: - CppFunction60(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59); - END_RCPP - } - - inline int nargs() { return 60; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59) ; -}; - - - -template -class CppFunction_WithFormals60 : public CppFunction { - public: - - CppFunction_WithFormals60(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59)); - END_RCPP - } - - inline int nargs() { return 60; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59); -}; - -template -class CppFunction_WithFormals60 : public CppFunction { - public: - CppFunction_WithFormals60(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59); - END_RCPP - } - - inline int nargs() { return 60; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59); -}; - - -template class CppFunction61 : public CppFunction { - public: - - CppFunction61(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60)); - END_RCPP - } - - inline int nargs() { return 61; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60) ; -}; - -template -class CppFunction61 : public CppFunction { - public: - CppFunction61(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60); - END_RCPP - } - - inline int nargs() { return 61; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60) ; -}; - - - -template -class CppFunction_WithFormals61 : public CppFunction { - public: - - CppFunction_WithFormals61(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60)); - END_RCPP - } - - inline int nargs() { return 61; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60); -}; - -template -class CppFunction_WithFormals61 : public CppFunction { - public: - CppFunction_WithFormals61(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60); - END_RCPP - } - - inline int nargs() { return 61; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60); -}; - - -template class CppFunction62 : public CppFunction { - public: - - CppFunction62(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61)); - END_RCPP - } - - inline int nargs() { return 62; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61) ; -}; - -template -class CppFunction62 : public CppFunction { - public: - CppFunction62(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61); - END_RCPP - } - - inline int nargs() { return 62; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61) ; -}; - - - -template -class CppFunction_WithFormals62 : public CppFunction { - public: - - CppFunction_WithFormals62(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61)); - END_RCPP - } - - inline int nargs() { return 62; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61); -}; - -template -class CppFunction_WithFormals62 : public CppFunction { - public: - CppFunction_WithFormals62(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61); - END_RCPP - } - - inline int nargs() { return 62; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61); -}; - - -template class CppFunction63 : public CppFunction { - public: - - CppFunction63(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62)); - END_RCPP - } - - inline int nargs() { return 63; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62) ; -}; - -template -class CppFunction63 : public CppFunction { - public: - CppFunction63(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62); - END_RCPP - } - - inline int nargs() { return 63; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62) ; -}; - - - -template -class CppFunction_WithFormals63 : public CppFunction { - public: - - CppFunction_WithFormals63(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62)); - END_RCPP - } - - inline int nargs() { return 63; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62); -}; - -template -class CppFunction_WithFormals63 : public CppFunction { - public: - CppFunction_WithFormals63(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62); - END_RCPP - } - - inline int nargs() { return 63; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62); -}; - - -template class CppFunction64 : public CppFunction { - public: - - CppFunction64(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63)); - END_RCPP - } - - inline int nargs() { return 64; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63) ; -}; - -template -class CppFunction64 : public CppFunction { - public: - CppFunction64(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63); - END_RCPP - } - - inline int nargs() { return 64; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63) ; -}; - - - -template -class CppFunction_WithFormals64 : public CppFunction { - public: - - CppFunction_WithFormals64(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63)); - END_RCPP - } - - inline int nargs() { return 64; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63); -}; - -template -class CppFunction_WithFormals64 : public CppFunction { - public: - CppFunction_WithFormals64(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63); - END_RCPP - } - - inline int nargs() { return 64; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63); -}; - - -template class CppFunction65 : public CppFunction { - public: - - CppFunction65(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - typename traits::input_parameter< U64 >::type x64(args[64]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63,x64)); - END_RCPP - } - - inline int nargs() { return 65; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun ; } - - private: - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64) ; -}; - -template -class CppFunction65 : public CppFunction { - public: - CppFunction65(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64) , const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - typename traits::input_parameter< U64 >::type x64(args[64]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63,x64); - END_RCPP - } - - inline int nargs() { return 65; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64) ; -}; - - - -template -class CppFunction_WithFormals65 : public CppFunction { - public: - - CppFunction_WithFormals65(RESULT_TYPE (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64) , Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - typename traits::input_parameter< U64 >::type x64(args[64]); - return Rcpp::module_wrap(ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63,x64)); - END_RCPP - } - - inline int nargs() { return 65; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - RESULT_TYPE (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64); -}; - -template -class CppFunction_WithFormals65 : public CppFunction { - public: - CppFunction_WithFormals65(void (*fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64), Rcpp::List formals_, const char* docstring = 0) : - CppFunction(docstring), formals(formals_), ptr_fun(fun) {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - typename traits::input_parameter< U0 >::type x0(args[0]); - typename traits::input_parameter< U1 >::type x1(args[1]); - typename traits::input_parameter< U2 >::type x2(args[2]); - typename traits::input_parameter< U3 >::type x3(args[3]); - typename traits::input_parameter< U4 >::type x4(args[4]); - typename traits::input_parameter< U5 >::type x5(args[5]); - typename traits::input_parameter< U6 >::type x6(args[6]); - typename traits::input_parameter< U7 >::type x7(args[7]); - typename traits::input_parameter< U8 >::type x8(args[8]); - typename traits::input_parameter< U9 >::type x9(args[9]); - typename traits::input_parameter< U10 >::type x10(args[10]); - typename traits::input_parameter< U11 >::type x11(args[11]); - typename traits::input_parameter< U12 >::type x12(args[12]); - typename traits::input_parameter< U13 >::type x13(args[13]); - typename traits::input_parameter< U14 >::type x14(args[14]); - typename traits::input_parameter< U15 >::type x15(args[15]); - typename traits::input_parameter< U16 >::type x16(args[16]); - typename traits::input_parameter< U17 >::type x17(args[17]); - typename traits::input_parameter< U18 >::type x18(args[18]); - typename traits::input_parameter< U19 >::type x19(args[19]); - typename traits::input_parameter< U20 >::type x20(args[20]); - typename traits::input_parameter< U21 >::type x21(args[21]); - typename traits::input_parameter< U22 >::type x22(args[22]); - typename traits::input_parameter< U23 >::type x23(args[23]); - typename traits::input_parameter< U24 >::type x24(args[24]); - typename traits::input_parameter< U25 >::type x25(args[25]); - typename traits::input_parameter< U26 >::type x26(args[26]); - typename traits::input_parameter< U27 >::type x27(args[27]); - typename traits::input_parameter< U28 >::type x28(args[28]); - typename traits::input_parameter< U29 >::type x29(args[29]); - typename traits::input_parameter< U30 >::type x30(args[30]); - typename traits::input_parameter< U31 >::type x31(args[31]); - typename traits::input_parameter< U32 >::type x32(args[32]); - typename traits::input_parameter< U33 >::type x33(args[33]); - typename traits::input_parameter< U34 >::type x34(args[34]); - typename traits::input_parameter< U35 >::type x35(args[35]); - typename traits::input_parameter< U36 >::type x36(args[36]); - typename traits::input_parameter< U37 >::type x37(args[37]); - typename traits::input_parameter< U38 >::type x38(args[38]); - typename traits::input_parameter< U39 >::type x39(args[39]); - typename traits::input_parameter< U40 >::type x40(args[40]); - typename traits::input_parameter< U41 >::type x41(args[41]); - typename traits::input_parameter< U42 >::type x42(args[42]); - typename traits::input_parameter< U43 >::type x43(args[43]); - typename traits::input_parameter< U44 >::type x44(args[44]); - typename traits::input_parameter< U45 >::type x45(args[45]); - typename traits::input_parameter< U46 >::type x46(args[46]); - typename traits::input_parameter< U47 >::type x47(args[47]); - typename traits::input_parameter< U48 >::type x48(args[48]); - typename traits::input_parameter< U49 >::type x49(args[49]); - typename traits::input_parameter< U50 >::type x50(args[50]); - typename traits::input_parameter< U51 >::type x51(args[51]); - typename traits::input_parameter< U52 >::type x52(args[52]); - typename traits::input_parameter< U53 >::type x53(args[53]); - typename traits::input_parameter< U54 >::type x54(args[54]); - typename traits::input_parameter< U55 >::type x55(args[55]); - typename traits::input_parameter< U56 >::type x56(args[56]); - typename traits::input_parameter< U57 >::type x57(args[57]); - typename traits::input_parameter< U58 >::type x58(args[58]); - typename traits::input_parameter< U59 >::type x59(args[59]); - typename traits::input_parameter< U60 >::type x60(args[60]); - typename traits::input_parameter< U61 >::type x61(args[61]); - typename traits::input_parameter< U62 >::type x62(args[62]); - typename traits::input_parameter< U63 >::type x63(args[63]); - typename traits::input_parameter< U64 >::type x64(args[64]); - ptr_fun(x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12,x13,x14,x15,x16,x17,x18,x19,x20,x21,x22,x23,x24,x25,x26,x27,x28,x29,x30,x31,x32,x33,x34,x35,x36,x37,x38,x39,x40,x41,x42,x43,x44,x45,x46,x47,x48,x49,x50,x51,x52,x53,x54,x55,x56,x57,x58,x59,x60,x61,x62,x63,x64); - END_RCPP - } - - inline int nargs() { return 65; } - inline bool is_void() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - SEXP get_formals() { return formals; } - inline DL_FUNC get_function_ptr() { return (DL_FUNC)ptr_fun; } - - private: - Rcpp::List formals; - void (*ptr_fun)(U0,U1,U2,U3,U4,U5,U6,U7,U8,U9,U10,U11,U12,U13,U14,U15,U16,U17,U18,U19,U20,U21,U22,U23,U24,U25,U26,U27,U28,U29,U30,U31,U32,U33,U34,U35,U36,U37,U38,U39,U40,U41,U42,U43,U44,U45,U46,U47,U48,U49,U50,U51,U52,U53,U54,U55,U56,U57,U58,U59,U60,U61,U62,U63,U64); -}; - - -} - -#endif - diff --git a/inst/include/Rcpp/module/Module_generated_CppMethod.h b/inst/include/Rcpp/module/Module_generated_CppMethod.h deleted file mode 100644 index 8bc397787..000000000 --- a/inst/include/Rcpp/module/Module_generated_CppMethod.h +++ /dev/null @@ -1,13817 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// Module_generated_CppMethod.h: -- generated helper code for Modules -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 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 . - -#ifndef Rcpp_Module_generated_CppMethod_h -#define Rcpp_Module_generated_CppMethod_h - -template class CppMethod0 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(void); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod0( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP*) { - return Rcpp::module_wrap((object->*met)()); - } - inline int nargs() { return 0; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod0 : public CppMethod { -public: - typedef void (Class::*Method)(void); - typedef CppMethod method_class; - CppMethod0( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* ) { - (object->*met)(); - return R_NilValue; - } - inline int nargs() { return 0; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod0 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(void) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod0( Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP*) { - return Rcpp::module_wrap((object->*met)()); - } - inline int nargs() { return 0; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod0 : public CppMethod { -public: - typedef void (Class::*Method)(void) const; - typedef CppMethod method_class; - const_CppMethod0( Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP*) { - (object->*met)( ); - return R_NilValue; - } - inline int nargs() { return 0; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class CppMethod1 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod1(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); - return Rcpp::module_wrap((object->*met)(x0)); - } - inline int nargs() { return 1; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod1 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0); - typedef CppMethod method_class; - - CppMethod1( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); - (object->*met)(x0); - return R_NilValue; - } - inline int nargs() { return 1; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod1 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod1(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); - return Rcpp::module_wrap((object->*met)(x0)); - } - inline int nargs() { return 1; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0 > class const_CppMethod1 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0) const; - typedef CppMethod method_class; - - const_CppMethod1(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); - (object->*met)(x0); - return R_NilValue; - } - inline int nargs() { return 1; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod2 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod2(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); - return Rcpp::module_wrap((object->*met)(x0, x1)); - } - inline int nargs() { return 2; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod2 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1); - typedef CppMethod method_class; - - CppMethod2( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); - (object->*met)(x0, x1); - return R_NilValue; - } - inline int nargs() { return 2; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod2 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod2(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); - return Rcpp::module_wrap((object->*met)(x0, x1)); - } - inline int nargs() { return 2; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0, typename U1 > class const_CppMethod2 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1) const; - typedef CppMethod method_class; - - const_CppMethod2(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); - (object->*met)(x0, x1); - return R_NilValue; - } - inline int nargs() { return 2; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod3 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod3(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2)); - } - inline int nargs() { return 3; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod3 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2); - typedef CppMethod method_class; - - CppMethod3( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); - (object->*met)(x0, x1, x2); - return R_NilValue; - } - inline int nargs() { return 3; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod3 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod3(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2)); - } - inline int nargs() { return 3; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0, typename U1, typename U2 > class const_CppMethod3 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2) const; - typedef CppMethod method_class; - - const_CppMethod3(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); - (object->*met)(x0, x1, x2); - return R_NilValue; - } - inline int nargs() { return 3; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod4 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod4(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3)); - } - inline int nargs() { return 4; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod4 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3); - typedef CppMethod method_class; - - CppMethod4( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); - (object->*met)(x0, x1, x2, x3); - return R_NilValue; - } - inline int nargs() { return 4; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod4 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod4(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3)); - } - inline int nargs() { return 4; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0, typename U1, typename U2, typename U3 > class const_CppMethod4 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3) const; - typedef CppMethod method_class; - - const_CppMethod4(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); - (object->*met)(x0, x1, x2, x3); - return R_NilValue; - } - inline int nargs() { return 4; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod5 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod5(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4)); - } - inline int nargs() { return 5; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod5 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4); - typedef CppMethod method_class; - - CppMethod5( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); - (object->*met)(x0, x1, x2, x3, x4); - return R_NilValue; - } - inline int nargs() { return 5; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod5 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod5(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4)); - } - inline int nargs() { return 5; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4 > class const_CppMethod5 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4) const; - typedef CppMethod method_class; - - const_CppMethod5(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); - (object->*met)(x0, x1, x2, x3, x4); - return R_NilValue; - } - inline int nargs() { return 5; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod6 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod6(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5)); - } - inline int nargs() { return 6; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod6 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5); - typedef CppMethod method_class; - - CppMethod6( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); - (object->*met)(x0, x1, x2, x3, x4, x5); - return R_NilValue; - } - inline int nargs() { return 6; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod6 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod6(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5)); - } - inline int nargs() { return 6; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5 > class const_CppMethod6 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5) const; - typedef CppMethod method_class; - - const_CppMethod6(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); - (object->*met)(x0, x1, x2, x3, x4, x5); - return R_NilValue; - } - inline int nargs() { return 6; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod7 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod7(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6)); - } - inline int nargs() { return 7; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod7 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6); - typedef CppMethod method_class; - - CppMethod7( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6); - return R_NilValue; - } - inline int nargs() { return 7; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod7 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod7(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6)); - } - inline int nargs() { return 7; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6 > class const_CppMethod7 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6) const; - typedef CppMethod method_class; - - const_CppMethod7(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6); - return R_NilValue; - } - inline int nargs() { return 7; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod8 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod8(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7)); - } - inline int nargs() { return 8; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod8 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7); - typedef CppMethod method_class; - - CppMethod8( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7); - return R_NilValue; - } - inline int nargs() { return 8; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod8 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod8(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7)); - } - inline int nargs() { return 8; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -} ; - -template < typename Class, typename U0, typename U1, typename U2, typename U3, typename U4, typename U5, typename U6, typename U7 > class const_CppMethod8 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7) const; - typedef CppMethod method_class; - - const_CppMethod8(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7); - return R_NilValue; - } - inline int nargs() { return 8; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod9 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod9(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8)); - } - inline int nargs() { return 9; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod9 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8); - typedef CppMethod method_class; - - CppMethod9( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8); - return R_NilValue; - } - inline int nargs() { return 9; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod9 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod9(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8)); - } - inline int nargs() { return 9; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod9 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8) const; - typedef CppMethod method_class; - - const_CppMethod9(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8); - return R_NilValue; - } - inline int nargs() { return 9; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod10 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod10(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)); - } - inline int nargs() { return 10; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod10 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9); - typedef CppMethod method_class; - - CppMethod10( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); - return R_NilValue; - } - inline int nargs() { return 10; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod10 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod10(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)); - } - inline int nargs() { return 10; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod10 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9) const; - typedef CppMethod method_class; - - const_CppMethod10(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); - return R_NilValue; - } - inline int nargs() { return 10; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod11 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod11(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)); - } - inline int nargs() { return 11; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod11 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10); - typedef CppMethod method_class; - - CppMethod11( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10); - return R_NilValue; - } - inline int nargs() { return 11; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod11 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod11(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)); - } - inline int nargs() { return 11; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod11 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10) const; - typedef CppMethod method_class; - - const_CppMethod11(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10); - return R_NilValue; - } - inline int nargs() { return 11; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod12 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod12(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)); - } - inline int nargs() { return 12; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod12 : public CppMethod { -public: - typedef void (Class::*Method)(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 method_class; - - CppMethod12( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11); - return R_NilValue; - } - inline int nargs() { return 12; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod12 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod12(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)); - } - inline int nargs() { return 12; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod12 : public CppMethod { -public: - typedef void (Class::*Method)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11) const; - typedef CppMethod method_class; - - const_CppMethod12(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11); - return R_NilValue; - } - inline int nargs() { return 12; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod13 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod13(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)); - } - inline int nargs() { return 13; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod13 : public CppMethod { -public: - typedef void (Class::*Method)(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 method_class; - - CppMethod13( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12); - return R_NilValue; - } - inline int nargs() { return 13; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod13 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod13(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)); - } - inline int nargs() { return 13; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod13 : public CppMethod { -public: - typedef void (Class::*Method)(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) const; - typedef CppMethod method_class; - - const_CppMethod13(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12); - return R_NilValue; - } - inline int nargs() { return 13; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod14 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod14(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)); - } - inline int nargs() { return 14; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod14 : public CppMethod { -public: - typedef void (Class::*Method)(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 method_class; - - CppMethod14( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13); - return R_NilValue; - } - inline int nargs() { return 14; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod14 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod14(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)); - } - inline int nargs() { return 14; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod14 : public CppMethod { -public: - typedef void (Class::*Method)(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) const; - typedef CppMethod method_class; - - const_CppMethod14(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13); - return R_NilValue; - } - inline int nargs() { return 14; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod15 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod15(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)); - } - inline int nargs() { return 15; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod15 : public CppMethod { -public: - typedef void (Class::*Method)(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 method_class; - - CppMethod15( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14); - return R_NilValue; - } - inline int nargs() { return 15; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod15 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod15(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)); - } - inline int nargs() { return 15; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod15 : public CppMethod { -public: - typedef void (Class::*Method)(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) const; - typedef CppMethod method_class; - - const_CppMethod15(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14); - return R_NilValue; - } - inline int nargs() { return 15; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod16 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod16(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)); - } - inline int nargs() { return 16; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod16 : public CppMethod { -public: - typedef void (Class::*Method)(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 method_class; - - CppMethod16( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15); - return R_NilValue; - } - inline int nargs() { return 16; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod16 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod16(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)); - } - inline int nargs() { return 16; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod16 : public CppMethod { -public: - typedef void (Class::*Method)(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) const; - typedef CppMethod method_class; - - const_CppMethod16(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15); - return R_NilValue; - } - inline int nargs() { return 16; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod17 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod17(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)); - } - inline int nargs() { return 17; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod17 : public CppMethod { -public: - typedef void (Class::*Method)(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 method_class; - - CppMethod17( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16); - return R_NilValue; - } - inline int nargs() { return 17; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod17 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod17(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)); - } - inline int nargs() { return 17; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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 const_CppMethod17 : public CppMethod { -public: - typedef void (Class::*Method)(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) const; - typedef CppMethod method_class; - - const_CppMethod17(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16); - return R_NilValue; - } - inline int nargs() { return 17; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod18 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod18(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)); - } - inline int nargs() { return 18; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod18 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17); - typedef CppMethod method_class; - - CppMethod18( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17); - return R_NilValue; - } - inline int nargs() { return 18; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod18 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod18(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)); - } - inline int nargs() { return 18; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17 > class const_CppMethod18 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17) const; - typedef CppMethod method_class; - - const_CppMethod18(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17); - return R_NilValue; - } - inline int nargs() { return 18; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod19 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod19(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)); - } - inline int nargs() { return 19; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod19 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18); - typedef CppMethod method_class; - - CppMethod19( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18); - return R_NilValue; - } - inline int nargs() { return 19; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod19 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod19(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)); - } - inline int nargs() { return 19; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18 > class const_CppMethod19 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18) const; - typedef CppMethod method_class; - - const_CppMethod19(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18); - return R_NilValue; - } - inline int nargs() { return 19; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod20 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod20(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)); - } - inline int nargs() { return 20; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod20 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19); - typedef CppMethod method_class; - - CppMethod20( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19); - return R_NilValue; - } - inline int nargs() { return 20; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod20 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod20(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)); - } - inline int nargs() { return 20; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19 > class const_CppMethod20 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19) const; - typedef CppMethod method_class; - - const_CppMethod20(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19); - return R_NilValue; - } - inline int nargs() { return 20; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod21 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod21(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)); - } - inline int nargs() { return 21; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod21 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20); - typedef CppMethod method_class; - - CppMethod21( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20); - return R_NilValue; - } - inline int nargs() { return 21; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod21 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod21(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)); - } - inline int nargs() { return 21; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20 > class const_CppMethod21 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20) const; - typedef CppMethod method_class; - - const_CppMethod21(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20); - return R_NilValue; - } - inline int nargs() { return 21; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod22 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod22(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)); - } - inline int nargs() { return 22; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod22 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21); - typedef CppMethod method_class; - - CppMethod22( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21); - return R_NilValue; - } - inline int nargs() { return 22; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod22 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod22(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)); - } - inline int nargs() { return 22; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21 > class const_CppMethod22 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21) const; - typedef CppMethod method_class; - - const_CppMethod22(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21); - return R_NilValue; - } - inline int nargs() { return 22; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod23 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod23(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)); - } - inline int nargs() { return 23; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod23 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22); - typedef CppMethod method_class; - - CppMethod23( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22); - return R_NilValue; - } - inline int nargs() { return 23; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod23 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod23(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)); - } - inline int nargs() { return 23; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22 > class const_CppMethod23 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22) const; - typedef CppMethod method_class; - - const_CppMethod23(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22); - return R_NilValue; - } - inline int nargs() { return 23; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod24 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod24(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23)); - } - inline int nargs() { return 24; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod24 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23); - typedef CppMethod method_class; - - CppMethod24( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23); - return R_NilValue; - } - inline int nargs() { return 24; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod24 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod24(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23)); - } - inline int nargs() { return 24; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23 > class const_CppMethod24 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23) const; - typedef CppMethod method_class; - - const_CppMethod24(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23); - return R_NilValue; - } - inline int nargs() { return 24; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod25 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod25(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24)); - } - inline int nargs() { return 25; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod25 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24); - typedef CppMethod method_class; - - CppMethod25( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24); - return R_NilValue; - } - inline int nargs() { return 25; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod25 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod25(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24)); - } - inline int nargs() { return 25; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24 > class const_CppMethod25 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24) const; - typedef CppMethod method_class; - - const_CppMethod25(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24); - return R_NilValue; - } - inline int nargs() { return 25; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod26 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod26(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25)); - } - inline int nargs() { return 26; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod26 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25); - typedef CppMethod method_class; - - CppMethod26( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25); - return R_NilValue; - } - inline int nargs() { return 26; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod26 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod26(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25)); - } - inline int nargs() { return 26; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25 > class const_CppMethod26 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25) const; - typedef CppMethod method_class; - - const_CppMethod26(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25); - return R_NilValue; - } - inline int nargs() { return 26; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod27 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod27(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26)); - } - inline int nargs() { return 27; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod27 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26); - typedef CppMethod method_class; - - CppMethod27( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26); - return R_NilValue; - } - inline int nargs() { return 27; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod27 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod27(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26)); - } - inline int nargs() { return 27; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26 > class const_CppMethod27 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26) const; - typedef CppMethod method_class; - - const_CppMethod27(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26); - return R_NilValue; - } - inline int nargs() { return 27; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod28 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod28(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27)); - } - inline int nargs() { return 28; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod28 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27); - typedef CppMethod method_class; - - CppMethod28( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27); - return R_NilValue; - } - inline int nargs() { return 28; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod28 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod28(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27)); - } - inline int nargs() { return 28; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27 > class const_CppMethod28 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27) const; - typedef CppMethod method_class; - - const_CppMethod28(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27); - return R_NilValue; - } - inline int nargs() { return 28; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod29 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod29(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28)); - } - inline int nargs() { return 29; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod29 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28); - typedef CppMethod method_class; - - CppMethod29( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28); - return R_NilValue; - } - inline int nargs() { return 29; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod29 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod29(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28)); - } - inline int nargs() { return 29; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28 > class const_CppMethod29 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28) const; - typedef CppMethod method_class; - - const_CppMethod29(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28); - return R_NilValue; - } - inline int nargs() { return 29; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod30 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod30(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29)); - } - inline int nargs() { return 30; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod30 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29); - typedef CppMethod method_class; - - CppMethod30( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29); - return R_NilValue; - } - inline int nargs() { return 30; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod30 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod30(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29)); - } - inline int nargs() { return 30; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29 > class const_CppMethod30 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29) const; - typedef CppMethod method_class; - - const_CppMethod30(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29); - return R_NilValue; - } - inline int nargs() { return 30; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod31 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod31(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30)); - } - inline int nargs() { return 31; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod31 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30); - typedef CppMethod method_class; - - CppMethod31( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30); - return R_NilValue; - } - inline int nargs() { return 31; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod31 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod31(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30)); - } - inline int nargs() { return 31; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30 > class const_CppMethod31 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30) const; - typedef CppMethod method_class; - - const_CppMethod31(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30); - return R_NilValue; - } - inline int nargs() { return 31; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod32 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod32(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31)); - } - inline int nargs() { return 32; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod32 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31); - typedef CppMethod method_class; - - CppMethod32( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31); - return R_NilValue; - } - inline int nargs() { return 32; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod32 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod32(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31)); - } - inline int nargs() { return 32; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31 > class const_CppMethod32 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31) const; - typedef CppMethod method_class; - - const_CppMethod32(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31); - return R_NilValue; - } - inline int nargs() { return 32; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod33 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod33(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32)); - } - inline int nargs() { return 33; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod33 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32); - typedef CppMethod method_class; - - CppMethod33( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32); - return R_NilValue; - } - inline int nargs() { return 33; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod33 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod33(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32)); - } - inline int nargs() { return 33; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32 > class const_CppMethod33 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32) const; - typedef CppMethod method_class; - - const_CppMethod33(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32); - return R_NilValue; - } - inline int nargs() { return 33; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod34 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod34(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33)); - } - inline int nargs() { return 34; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod34 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33); - typedef CppMethod method_class; - - CppMethod34( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33); - return R_NilValue; - } - inline int nargs() { return 34; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod34 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod34(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33)); - } - inline int nargs() { return 34; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33 > class const_CppMethod34 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33) const; - typedef CppMethod method_class; - - const_CppMethod34(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33); - return R_NilValue; - } - inline int nargs() { return 34; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod35 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod35(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34)); - } - inline int nargs() { return 35; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod35 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34); - typedef CppMethod method_class; - - CppMethod35( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34); - return R_NilValue; - } - inline int nargs() { return 35; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod35 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod35(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34)); - } - inline int nargs() { return 35; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34 > class const_CppMethod35 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34) const; - typedef CppMethod method_class; - - const_CppMethod35(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34); - return R_NilValue; - } - inline int nargs() { return 35; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod36 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod36(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35)); - } - inline int nargs() { return 36; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod36 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35); - typedef CppMethod method_class; - - CppMethod36( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35); - return R_NilValue; - } - inline int nargs() { return 36; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod36 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod36(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35)); - } - inline int nargs() { return 36; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35 > class const_CppMethod36 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35) const; - typedef CppMethod method_class; - - const_CppMethod36(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35); - return R_NilValue; - } - inline int nargs() { return 36; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod37 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod37(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36)); - } - inline int nargs() { return 37; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod37 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36); - typedef CppMethod method_class; - - CppMethod37( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36); - return R_NilValue; - } - inline int nargs() { return 37; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod37 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod37(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36)); - } - inline int nargs() { return 37; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36 > class const_CppMethod37 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36) const; - typedef CppMethod method_class; - - const_CppMethod37(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36); - return R_NilValue; - } - inline int nargs() { return 37; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod38 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod38(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37)); - } - inline int nargs() { return 38; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod38 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37); - typedef CppMethod method_class; - - CppMethod38( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37); - return R_NilValue; - } - inline int nargs() { return 38; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod38 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod38(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37)); - } - inline int nargs() { return 38; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37 > class const_CppMethod38 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37) const; - typedef CppMethod method_class; - - const_CppMethod38(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37); - return R_NilValue; - } - inline int nargs() { return 38; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod39 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod39(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38)); - } - inline int nargs() { return 39; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod39 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38); - typedef CppMethod method_class; - - CppMethod39( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38); - return R_NilValue; - } - inline int nargs() { return 39; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod39 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod39(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38)); - } - inline int nargs() { return 39; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38 > class const_CppMethod39 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38) const; - typedef CppMethod method_class; - - const_CppMethod39(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38); - return R_NilValue; - } - inline int nargs() { return 39; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod40 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod40(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39)); - } - inline int nargs() { return 40; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod40 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39); - typedef CppMethod method_class; - - CppMethod40( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39); - return R_NilValue; - } - inline int nargs() { return 40; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod40 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod40(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39)); - } - inline int nargs() { return 40; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39 > class const_CppMethod40 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39) const; - typedef CppMethod method_class; - - const_CppMethod40(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39); - return R_NilValue; - } - inline int nargs() { return 40; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod41 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod41(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40)); - } - inline int nargs() { return 41; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod41 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40); - typedef CppMethod method_class; - - CppMethod41( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40); - return R_NilValue; - } - inline int nargs() { return 41; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod41 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod41(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40)); - } - inline int nargs() { return 41; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40 > class const_CppMethod41 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40) const; - typedef CppMethod method_class; - - const_CppMethod41(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40); - return R_NilValue; - } - inline int nargs() { return 41; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod42 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod42(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41)); - } - inline int nargs() { return 42; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod42 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41); - typedef CppMethod method_class; - - CppMethod42( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41); - return R_NilValue; - } - inline int nargs() { return 42; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod42 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod42(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41)); - } - inline int nargs() { return 42; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41 > class const_CppMethod42 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41) const; - typedef CppMethod method_class; - - const_CppMethod42(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41); - return R_NilValue; - } - inline int nargs() { return 42; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod43 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod43(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42)); - } - inline int nargs() { return 43; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod43 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42); - typedef CppMethod method_class; - - CppMethod43( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42); - return R_NilValue; - } - inline int nargs() { return 43; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod43 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod43(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42)); - } - inline int nargs() { return 43; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42 > class const_CppMethod43 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42) const; - typedef CppMethod method_class; - - const_CppMethod43(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42); - return R_NilValue; - } - inline int nargs() { return 43; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod44 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod44(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43)); - } - inline int nargs() { return 44; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod44 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43); - typedef CppMethod method_class; - - CppMethod44( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43); - return R_NilValue; - } - inline int nargs() { return 44; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod44 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod44(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43)); - } - inline int nargs() { return 44; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43 > class const_CppMethod44 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43) const; - typedef CppMethod method_class; - - const_CppMethod44(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43); - return R_NilValue; - } - inline int nargs() { return 44; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod45 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod45(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44)); - } - inline int nargs() { return 45; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod45 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44); - typedef CppMethod method_class; - - CppMethod45( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44); - return R_NilValue; - } - inline int nargs() { return 45; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod45 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod45(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44)); - } - inline int nargs() { return 45; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44 > class const_CppMethod45 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44) const; - typedef CppMethod method_class; - - const_CppMethod45(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44); - return R_NilValue; - } - inline int nargs() { return 45; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod46 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod46(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45)); - } - inline int nargs() { return 46; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod46 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45); - typedef CppMethod method_class; - - CppMethod46( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45); - return R_NilValue; - } - inline int nargs() { return 46; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod46 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod46(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45)); - } - inline int nargs() { return 46; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45 > class const_CppMethod46 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45) const; - typedef CppMethod method_class; - - const_CppMethod46(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45); - return R_NilValue; - } - inline int nargs() { return 46; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod47 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod47(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46)); - } - inline int nargs() { return 47; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod47 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46); - typedef CppMethod method_class; - - CppMethod47( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46); - return R_NilValue; - } - inline int nargs() { return 47; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod47 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod47(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46)); - } - inline int nargs() { return 47; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46 > class const_CppMethod47 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46) const; - typedef CppMethod method_class; - - const_CppMethod47(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46); - return R_NilValue; - } - inline int nargs() { return 47; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod48 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod48(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47)); - } - inline int nargs() { return 48; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod48 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47); - typedef CppMethod method_class; - - CppMethod48( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47); - return R_NilValue; - } - inline int nargs() { return 48; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod48 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod48(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47)); - } - inline int nargs() { return 48; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47 > class const_CppMethod48 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47) const; - typedef CppMethod method_class; - - const_CppMethod48(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47); - return R_NilValue; - } - inline int nargs() { return 48; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod49 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod49(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48)); - } - inline int nargs() { return 49; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod49 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48); - typedef CppMethod method_class; - - CppMethod49( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48); - return R_NilValue; - } - inline int nargs() { return 49; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod49 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod49(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48)); - } - inline int nargs() { return 49; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48 > class const_CppMethod49 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48) const; - typedef CppMethod method_class; - - const_CppMethod49(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48); - return R_NilValue; - } - inline int nargs() { return 49; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod50 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod50(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49)); - } - inline int nargs() { return 50; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod50 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49); - typedef CppMethod method_class; - - CppMethod50( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49); - return R_NilValue; - } - inline int nargs() { return 50; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod50 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod50(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49)); - } - inline int nargs() { return 50; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49 > class const_CppMethod50 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49) const; - typedef CppMethod method_class; - - const_CppMethod50(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49); - return R_NilValue; - } - inline int nargs() { return 50; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod51 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod51(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50)); - } - inline int nargs() { return 51; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod51 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50); - typedef CppMethod method_class; - - CppMethod51( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50); - return R_NilValue; - } - inline int nargs() { return 51; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod51 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod51(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50)); - } - inline int nargs() { return 51; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50 > class const_CppMethod51 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50) const; - typedef CppMethod method_class; - - const_CppMethod51(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50); - return R_NilValue; - } - inline int nargs() { return 51; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod52 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod52(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51)); - } - inline int nargs() { return 52; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod52 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51); - typedef CppMethod method_class; - - CppMethod52( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51); - return R_NilValue; - } - inline int nargs() { return 52; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod52 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod52(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51)); - } - inline int nargs() { return 52; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51 > class const_CppMethod52 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51) const; - typedef CppMethod method_class; - - const_CppMethod52(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51); - return R_NilValue; - } - inline int nargs() { return 52; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod53 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod53(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52)); - } - inline int nargs() { return 53; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod53 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52); - typedef CppMethod method_class; - - CppMethod53( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52); - return R_NilValue; - } - inline int nargs() { return 53; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod53 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod53(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52)); - } - inline int nargs() { return 53; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52 > class const_CppMethod53 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52) const; - typedef CppMethod method_class; - - const_CppMethod53(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52); - return R_NilValue; - } - inline int nargs() { return 53; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod54 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod54(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53)); - } - inline int nargs() { return 54; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod54 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53); - typedef CppMethod method_class; - - CppMethod54( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53); - return R_NilValue; - } - inline int nargs() { return 54; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod54 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod54(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53)); - } - inline int nargs() { return 54; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53 > class const_CppMethod54 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53) const; - typedef CppMethod method_class; - - const_CppMethod54(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53); - return R_NilValue; - } - inline int nargs() { return 54; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod55 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod55(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54)); - } - inline int nargs() { return 55; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod55 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54); - typedef CppMethod method_class; - - CppMethod55( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54); - return R_NilValue; - } - inline int nargs() { return 55; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod55 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod55(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54)); - } - inline int nargs() { return 55; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54 > class const_CppMethod55 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54) const; - typedef CppMethod method_class; - - const_CppMethod55(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54); - return R_NilValue; - } - inline int nargs() { return 55; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod56 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod56(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55)); - } - inline int nargs() { return 56; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod56 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55); - typedef CppMethod method_class; - - CppMethod56( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55); - return R_NilValue; - } - inline int nargs() { return 56; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod56 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod56(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55)); - } - inline int nargs() { return 56; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55 > class const_CppMethod56 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55) const; - typedef CppMethod method_class; - - const_CppMethod56(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55); - return R_NilValue; - } - inline int nargs() { return 56; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod57 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod57(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56)); - } - inline int nargs() { return 57; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod57 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56); - typedef CppMethod method_class; - - CppMethod57( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56); - return R_NilValue; - } - inline int nargs() { return 57; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod57 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod57(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56)); - } - inline int nargs() { return 57; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56 > class const_CppMethod57 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56) const; - typedef CppMethod method_class; - - const_CppMethod57(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56); - return R_NilValue; - } - inline int nargs() { return 57; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod58 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod58(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57)); - } - inline int nargs() { return 58; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod58 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57); - typedef CppMethod method_class; - - CppMethod58( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57); - return R_NilValue; - } - inline int nargs() { return 58; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod58 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod58(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57)); - } - inline int nargs() { return 58; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57 > class const_CppMethod58 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57) const; - typedef CppMethod method_class; - - const_CppMethod58(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57); - return R_NilValue; - } - inline int nargs() { return 58; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod59 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod59(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58)); - } - inline int nargs() { return 59; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod59 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58); - typedef CppMethod method_class; - - CppMethod59( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58); - return R_NilValue; - } - inline int nargs() { return 59; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod59 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod59(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58)); - } - inline int nargs() { return 59; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57, typename U58 > class const_CppMethod59 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58) const; - typedef CppMethod method_class; - - const_CppMethod59(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58); - return R_NilValue; - } - inline int nargs() { return 59; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod60 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod60(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59)); - } - inline int nargs() { return 60; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod60 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59); - typedef CppMethod method_class; - - CppMethod60( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59); - return R_NilValue; - } - inline int nargs() { return 60; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod60 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod60(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59)); - } - inline int nargs() { return 60; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57, typename U58, typename U59 > class const_CppMethod60 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59) const; - typedef CppMethod method_class; - - const_CppMethod60(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59); - return R_NilValue; - } - inline int nargs() { return 60; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod61 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod61(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60)); - } - inline int nargs() { return 61; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod61 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60); - typedef CppMethod method_class; - - CppMethod61( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60); - return R_NilValue; - } - inline int nargs() { return 61; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod61 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod61(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60)); - } - inline int nargs() { return 61; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57, typename U58, typename U59, typename U60 > class const_CppMethod61 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60) const; - typedef CppMethod method_class; - - const_CppMethod61(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60); - return R_NilValue; - } - inline int nargs() { return 61; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod62 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod62(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61)); - } - inline int nargs() { return 62; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod62 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61); - typedef CppMethod method_class; - - CppMethod62( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61); - return R_NilValue; - } - inline int nargs() { return 62; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod62 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod62(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61)); - } - inline int nargs() { return 62; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57, typename U58, typename U59, typename U60, typename U61 > class const_CppMethod62 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61) const; - typedef CppMethod method_class; - - const_CppMethod62(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61); - return R_NilValue; - } - inline int nargs() { return 62; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod63 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod63(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62)); - } - inline int nargs() { return 63; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod63 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62); - typedef CppMethod method_class; - - CppMethod63( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62); - return R_NilValue; - } - inline int nargs() { return 63; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod63 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod63(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62)); - } - inline int nargs() { return 63; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57, typename U58, typename U59, typename U60, typename U61, typename U62 > class const_CppMethod63 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62) const; - typedef CppMethod method_class; - - const_CppMethod63(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62); - return R_NilValue; - } - inline int nargs() { return 63; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod64 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod64(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63)); - } - inline int nargs() { return 64; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod64 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63); - typedef CppMethod method_class; - - CppMethod64( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63); - return R_NilValue; - } - inline int nargs() { return 64; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod64 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod64(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63)); - } - inline int nargs() { return 64; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57, typename U58, typename U59, typename U60, typename U61, typename U62, typename U63 > class const_CppMethod64 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63) const; - typedef CppMethod method_class; - - const_CppMethod64(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63); - return R_NilValue; - } - inline int nargs() { return 64; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - - -template class CppMethod65 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - CppMethod65(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); -typename Rcpp::traits::input_parameter::type x64(args[64]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64)); - } - inline int nargs() { return 65; } - inline bool is_void() { return false; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class CppMethod65 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64); - typedef CppMethod method_class; - - CppMethod65( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); -typename Rcpp::traits::input_parameter::type x64(args[64]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64); - return R_NilValue; - } - inline int nargs() { return 65; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class const_CppMethod65 : public CppMethod { -public: - typedef RESULT_TYPE (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64) const; - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - const_CppMethod65(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); -typename Rcpp::traits::input_parameter::type x64(args[64]); - return Rcpp::module_wrap((object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64)); - } - inline int nargs() { return 65; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -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, typename U17, typename U18, typename U19, typename U20, typename U21, typename U22, typename U23, typename U24, typename U25, typename U26, typename U27, typename U28, typename U29, typename U30, typename U31, typename U32, typename U33, typename U34, typename U35, typename U36, typename U37, typename U38, typename U39, typename U40, typename U41, typename U42, typename U43, typename U44, typename U45, typename U46, typename U47, typename U48, typename U49, typename U50, typename U51, typename U52, typename U53, typename U54, typename U55, typename U56, typename U57, typename U58, typename U59, typename U60, typename U61, typename U62, typename U63, typename U64 > class const_CppMethod65 : public CppMethod { -public: - typedef void (Class::*Method)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64) const; - typedef CppMethod method_class; - - const_CppMethod65(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter::type x0(args[0]); -typename Rcpp::traits::input_parameter::type x1(args[1]); -typename Rcpp::traits::input_parameter::type x2(args[2]); -typename Rcpp::traits::input_parameter::type x3(args[3]); -typename Rcpp::traits::input_parameter::type x4(args[4]); -typename Rcpp::traits::input_parameter::type x5(args[5]); -typename Rcpp::traits::input_parameter::type x6(args[6]); -typename Rcpp::traits::input_parameter::type x7(args[7]); -typename Rcpp::traits::input_parameter::type x8(args[8]); -typename Rcpp::traits::input_parameter::type x9(args[9]); -typename Rcpp::traits::input_parameter::type x10(args[10]); -typename Rcpp::traits::input_parameter::type x11(args[11]); -typename Rcpp::traits::input_parameter::type x12(args[12]); -typename Rcpp::traits::input_parameter::type x13(args[13]); -typename Rcpp::traits::input_parameter::type x14(args[14]); -typename Rcpp::traits::input_parameter::type x15(args[15]); -typename Rcpp::traits::input_parameter::type x16(args[16]); -typename Rcpp::traits::input_parameter::type x17(args[17]); -typename Rcpp::traits::input_parameter::type x18(args[18]); -typename Rcpp::traits::input_parameter::type x19(args[19]); -typename Rcpp::traits::input_parameter::type x20(args[20]); -typename Rcpp::traits::input_parameter::type x21(args[21]); -typename Rcpp::traits::input_parameter::type x22(args[22]); -typename Rcpp::traits::input_parameter::type x23(args[23]); -typename Rcpp::traits::input_parameter::type x24(args[24]); -typename Rcpp::traits::input_parameter::type x25(args[25]); -typename Rcpp::traits::input_parameter::type x26(args[26]); -typename Rcpp::traits::input_parameter::type x27(args[27]); -typename Rcpp::traits::input_parameter::type x28(args[28]); -typename Rcpp::traits::input_parameter::type x29(args[29]); -typename Rcpp::traits::input_parameter::type x30(args[30]); -typename Rcpp::traits::input_parameter::type x31(args[31]); -typename Rcpp::traits::input_parameter::type x32(args[32]); -typename Rcpp::traits::input_parameter::type x33(args[33]); -typename Rcpp::traits::input_parameter::type x34(args[34]); -typename Rcpp::traits::input_parameter::type x35(args[35]); -typename Rcpp::traits::input_parameter::type x36(args[36]); -typename Rcpp::traits::input_parameter::type x37(args[37]); -typename Rcpp::traits::input_parameter::type x38(args[38]); -typename Rcpp::traits::input_parameter::type x39(args[39]); -typename Rcpp::traits::input_parameter::type x40(args[40]); -typename Rcpp::traits::input_parameter::type x41(args[41]); -typename Rcpp::traits::input_parameter::type x42(args[42]); -typename Rcpp::traits::input_parameter::type x43(args[43]); -typename Rcpp::traits::input_parameter::type x44(args[44]); -typename Rcpp::traits::input_parameter::type x45(args[45]); -typename Rcpp::traits::input_parameter::type x46(args[46]); -typename Rcpp::traits::input_parameter::type x47(args[47]); -typename Rcpp::traits::input_parameter::type x48(args[48]); -typename Rcpp::traits::input_parameter::type x49(args[49]); -typename Rcpp::traits::input_parameter::type x50(args[50]); -typename Rcpp::traits::input_parameter::type x51(args[51]); -typename Rcpp::traits::input_parameter::type x52(args[52]); -typename Rcpp::traits::input_parameter::type x53(args[53]); -typename Rcpp::traits::input_parameter::type x54(args[54]); -typename Rcpp::traits::input_parameter::type x55(args[55]); -typename Rcpp::traits::input_parameter::type x56(args[56]); -typename Rcpp::traits::input_parameter::type x57(args[57]); -typename Rcpp::traits::input_parameter::type x58(args[58]); -typename Rcpp::traits::input_parameter::type x59(args[59]); -typename Rcpp::traits::input_parameter::type x60(args[60]); -typename Rcpp::traits::input_parameter::type x61(args[61]); -typename Rcpp::traits::input_parameter::type x62(args[62]); -typename Rcpp::traits::input_parameter::type x63(args[63]); -typename Rcpp::traits::input_parameter::type x64(args[64]); - (object->*met)(x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64); - return R_NilValue; - } - inline int nargs() { return 65; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name ) { Rcpp::signature(s, name); } - -private: - Method met ; -} ; - - - -#endif - diff --git a/inst/include/Rcpp/module/Module_generated_Factory.h b/inst/include/Rcpp/module/Module_generated_Factory.h deleted file mode 100644 index 0faa85808..000000000 --- a/inst/include/Rcpp/module/Module_generated_Factory.h +++ /dev/null @@ -1,179 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Module_generated_Factory.h: Rcpp R/C++ interface class library -- Rcpp module class factories -// -// Copyright (C) 2012 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 . - -#ifndef Rcpp_Module_generated_Factory_h -#define Rcpp_Module_generated_Factory_h - -template -class Factory_Base { -public: - virtual Class* get_new( SEXP* args, int nargs ) = 0 ; - virtual int nargs() = 0 ; - virtual void signature(std::string& s, const std::string& class_name) = 0 ; -} ; - -template -class Factory_0 : public Factory_Base{ - public: - Factory_0( Class* (*fun)(void) ) : ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun() ; - } - virtual int nargs(){ return 0 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } - private: - Class* (*ptr_fun)(void) ; -} ; -template -class Factory_1 : public Factory_Base{ -public: - Factory_1( Class* (*fun)(U0) ) :ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun( bare_as(args[0]) ) ; - } - virtual int nargs(){ return 1 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -private: - Class* (*ptr_fun)(U0) ; -} ; -template -class Factory_2 : public Factory_Base{ -public: - Factory_2( Class* (*fun)(U0, U1) ) :ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun( - bare_as(args[0]), - bare_as(args[1]) - ) ; - } - virtual int nargs(){ return 2 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -private: - Class* (*ptr_fun)(U0, U1) ; -} ; -template -class Factory_3 : public Factory_Base{ -public: - Factory_3( Class* (*fun)(U0, U1, U2) ) :ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun( - bare_as(args[0]), - bare_as(args[1]), - bare_as(args[2]) - ) ; - } - virtual int nargs(){ return 3 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -private: - Class* (*ptr_fun)(U0, U1, U2) ; -} ; -template -class Factory_4 : public Factory_Base{ -public: - Factory_4( Class* (*fun)(U0, U1, U2, U3) ) :ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun( - bare_as(args[0]), - bare_as(args[1]), - bare_as(args[2]), - bare_as(args[3]) - ) ; - } - virtual int nargs(){ return 4 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -private: - Class* (*ptr_fun)(U0, U1, U2, U3) ; -} ; -template -class Factory_5 : public Factory_Base{ -public: - Factory_5( Class* (*fun)(U0, U1, U2, U3, U4) ) :ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun( - bare_as(args[0]), - bare_as(args[1]), - bare_as(args[2]), - bare_as(args[3]), - bare_as(args[4]) - ) ; - } - virtual int nargs(){ return 5 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -private: - Class* (*ptr_fun)(U0, U1, U2, U3, U4) ; -} ; -template -class Factory_6 : public Factory_Base{ -public: - Factory_6( Class* (*fun)(U0, U1, U2, U3, U4, U5) ) :ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun( - bare_as(args[0]), - bare_as(args[1]), - bare_as(args[2]), - bare_as(args[3]), - bare_as(args[4]), - bare_as(args[5]) - ) ; - } - virtual int nargs(){ return 6 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -private: - Class* (*ptr_fun)(U0, U1, U2, U3, U4, U5) ; -} ; -template -class Factory_7 : public Factory_Base{ -public: - Factory_7( Class* (*fun)(U0, U1, U2, U3, U4, U5, U6) ) :ptr_fun(fun){} - virtual Class* get_new( SEXP* args, int nargs ){ - return ptr_fun( - bare_as(args[0]), - bare_as(args[1]), - bare_as(args[2]), - bare_as(args[3]), - bare_as(args[4]), - bare_as(args[5]), - bare_as(args[6]) - ) ; - } - virtual int nargs(){ return 7 ; } - virtual void signature(std::string& s, const std::string& class_name ){ - ctor_signature(s, class_name) ; - } -private: - Class* (*ptr_fun)(U0, U1, U2, U3, U4, U5, U6) ; -} ; - -#endif diff --git a/inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h b/inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h deleted file mode 100644 index 2ff80c384..000000000 --- a/inst/include/Rcpp/module/Module_generated_Pointer_CppMethod.h +++ /dev/null @@ -1,13948 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Module_generated_PointerCppMethod.h: -- generated helper code for Modules -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 Doug Bates, 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 . - -#ifndef Rcpp_Module_generated_Pointer_CppMethod_h -#define Rcpp_Module_generated_Pointer_CppMethod_h - - -template class Pointer_CppMethod0 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*) ; - typedef CppMethod method_class ; - Pointer_CppMethod0( Method m) : method_class(), met(m){} - SEXP operator()( Class* object, SEXP* ){ - return Rcpp::module_wrap( met(object) ) ; - } - inline int nargs(){ return 0 ; } - inline bool is_void(){ return false ; } - inline bool is_const(){ return false ; } - inline void signature(std::string& s, const char* name){ Rcpp::signature(s, name) ; } - -private: - Method met ; -} ; - -template class Pointer_CppMethod0 : public CppMethod { -public: - typedef void (*Method)(Class*) ; - typedef CppMethod method_class ; - Pointer_CppMethod0( Method m) : method_class(), met(m){} - SEXP operator()( Class* object, SEXP* ){ - met( object ) ; - return R_NilValue ; - } - inline int nargs(){ return 0 ; } - inline bool is_void(){ return true ; } - inline bool is_const(){ return false ; } - inline void signature(std::string& s, const char* name){ Rcpp::signature(s, name) ; } - -private: - Method met ; -} ; - - - - -template class Const_Pointer_CppMethod0 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*) ; - typedef CppMethod method_class ; - Const_Pointer_CppMethod0( Method m) : method_class(), met(m){} - SEXP operator()( Class* object, SEXP* ){ - return Rcpp::module_wrap( met(object) ) ; - } - inline int nargs(){ return 0 ; } - inline bool is_void(){ return false ; } - inline bool is_const(){ return true ; } - inline void signature(std::string& s, const char* name){ Rcpp::signature(s, name) ; } - -private: - Method met ; -} ; - -template class Const_Pointer_CppMethod0 : public CppMethod { -public: - typedef void (*Method)(const Class*) ; - typedef CppMethod method_class ; - Const_Pointer_CppMethod0( Method m) : method_class(), met(m){} - SEXP operator()( Class* object, SEXP* ){ - met( object ) ; - return R_NilValue ; - } - inline int nargs(){ return 0 ; } - inline bool is_void(){ return true ; } - inline bool is_const(){ return true ; } - - inline void signature(std::string& s, const char* name){ Rcpp::signature(s, name) ; } - -private: - Method met ; -}; - - - -template class Pointer_CppMethod1 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod1(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; - return Rcpp::module_wrap(met(object, x0)); - } - inline int nargs(){ return 1; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod1 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0); - typedef CppMethod method_class; - - Pointer_CppMethod1(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; - met(object, x0); - return R_NilValue; - } - inline int nargs() { return 1; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod1 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod1(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; - return Rcpp::module_wrap(met(object, x0)); - } - inline int nargs() { return 1; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod1 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0); - typedef CppMethod method_class; - - Const_Pointer_CppMethod1( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; - met(object, x0); - return R_NilValue; - } - inline int nargs() { return 1; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod2 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod2(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; - return Rcpp::module_wrap(met(object, x0, x1)); - } - inline int nargs(){ return 2; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod2 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0, U1 u1); - typedef CppMethod method_class; - - Pointer_CppMethod2(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; - met(object, x0, x1); - return R_NilValue; - } - inline int nargs() { return 2; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod2 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod2(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; - return Rcpp::module_wrap(met(object, x0, x1)); - } - inline int nargs() { return 2; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod2 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1); - typedef CppMethod method_class; - - Const_Pointer_CppMethod2( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; - met(object, x0, x1); - return R_NilValue; - } - inline int nargs() { return 2; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod3 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod3(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2)); - } - inline int nargs(){ return 3; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod3 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2); - typedef CppMethod method_class; - - Pointer_CppMethod3(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; - met(object, x0, x1, x2); - return R_NilValue; - } - inline int nargs() { return 3; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod3 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod3(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2)); - } - inline int nargs() { return 3; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod3 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2); - typedef CppMethod method_class; - - Const_Pointer_CppMethod3( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; - met(object, x0, x1, x2); - return R_NilValue; - } - inline int nargs() { return 3; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod4 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod4(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3)); - } - inline int nargs(){ return 4; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod4 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3); - typedef CppMethod method_class; - - Pointer_CppMethod4(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; - met(object, x0, x1, x2, x3); - return R_NilValue; - } - inline int nargs() { return 4; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod4 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod4(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3)); - } - inline int nargs() { return 4; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod4 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3); - typedef CppMethod method_class; - - Const_Pointer_CppMethod4( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; - met(object, x0, x1, x2, x3); - return R_NilValue; - } - inline int nargs() { return 4; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod5 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod5(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4)); - } - inline int nargs(){ return 5; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod5 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4); - typedef CppMethod method_class; - - Pointer_CppMethod5(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; - met(object, x0, x1, x2, x3, x4); - return R_NilValue; - } - inline int nargs() { return 5; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod5 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod5(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4)); - } - inline int nargs() { return 5; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod5 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4); - typedef CppMethod method_class; - - Const_Pointer_CppMethod5( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; - met(object, x0, x1, x2, x3, x4); - return R_NilValue; - } - inline int nargs() { return 5; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod6 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod6(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5)); - } - inline int nargs(){ return 6; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod6 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5); - typedef CppMethod method_class; - - Pointer_CppMethod6(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; - met(object, x0, x1, x2, x3, x4, x5); - return R_NilValue; - } - inline int nargs() { return 6; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod6 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod6(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5)); - } - inline int nargs() { return 6; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod6 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5); - typedef CppMethod method_class; - - Const_Pointer_CppMethod6( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; - met(object, x0, x1, x2, x3, x4, x5); - return R_NilValue; - } - inline int nargs() { return 6; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod7 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod7(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6)); - } - inline int nargs(){ return 7; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod7 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6); - typedef CppMethod method_class; - - Pointer_CppMethod7(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6); - return R_NilValue; - } - inline int nargs() { return 7; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod7 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod7(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6)); - } - inline int nargs() { return 7; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod7 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6); - typedef CppMethod method_class; - - Const_Pointer_CppMethod7( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6); - return R_NilValue; - } - inline int nargs() { return 7; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod8 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod8(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7)); - } - inline int nargs(){ return 8; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod8 : public CppMethod { -public: - typedef void (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7); - typedef CppMethod method_class; - - Pointer_CppMethod8(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7); - return R_NilValue; - } - inline int nargs() { return 8; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod8 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod8(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7)); - } - inline int nargs() { return 8; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod8 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7); - typedef CppMethod method_class; - - Const_Pointer_CppMethod8( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7); - return R_NilValue; - } - inline int nargs() { return 8; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod9 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod9(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8)); - } - inline int nargs(){ return 9; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod9 : public CppMethod { -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 method_class; - - Pointer_CppMethod9(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8); - return R_NilValue; - } - inline int nargs() { return 9; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod9 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod9(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8)); - } - inline int nargs() { return 9; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod9 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8); - typedef CppMethod method_class; - - Const_Pointer_CppMethod9( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8); - return R_NilValue; - } - inline int nargs() { return 9; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod10 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod10(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)); - } - inline int nargs(){ return 10; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod10 : public CppMethod { -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 method_class; - - Pointer_CppMethod10(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); - return R_NilValue; - } - inline int nargs() { return 10; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod10 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod10(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9)); - } - inline int nargs() { return 10; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod10 : public CppMethod { -public: - typedef void (*Method)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9); - typedef CppMethod method_class; - - Const_Pointer_CppMethod10( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9); - return R_NilValue; - } - inline int nargs() { return 10; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod11 : public CppMethod { -public: - typedef RESULT_TYPE (*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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod11(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)); - } - inline int nargs(){ return 11; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod11 : public CppMethod { -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 method_class; - - Pointer_CppMethod11(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10); - return R_NilValue; - } - inline int nargs() { return 11; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod11 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod11(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)); - } - inline int nargs() { return 11; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod11 : public CppMethod { -public: - typedef void (*Method)(const 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 method_class; - - Const_Pointer_CppMethod11( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10); - return R_NilValue; - } - inline int nargs() { return 11; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod12 : public CppMethod { -public: - typedef RESULT_TYPE (*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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod12(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)); - } - inline int nargs(){ return 12; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod12 : public CppMethod { -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 method_class; - - Pointer_CppMethod12(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11); - return R_NilValue; - } - inline int nargs() { return 12; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod12 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod12(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)); - } - inline int nargs() { return 12; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod12 : public CppMethod { -public: - typedef void (*Method)(const 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 method_class; - - Const_Pointer_CppMethod12( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11); - return R_NilValue; - } - inline int nargs() { return 12; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod13 : public CppMethod { -public: - typedef RESULT_TYPE (*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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod13(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)); - } - inline int nargs(){ return 13; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod13 : public CppMethod { -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 method_class; - - Pointer_CppMethod13(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12); - return R_NilValue; - } - inline int nargs() { return 13; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod13 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod13(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)); - } - inline int nargs() { return 13; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod13 : public CppMethod { -public: - typedef void (*Method)(const 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 method_class; - - Const_Pointer_CppMethod13( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12); - return R_NilValue; - } - inline int nargs() { return 13; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod14 : public CppMethod { -public: - typedef RESULT_TYPE (*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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod14(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)); - } - inline int nargs(){ return 14; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod14 : public CppMethod { -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 method_class; - - Pointer_CppMethod14(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13); - return R_NilValue; - } - inline int nargs() { return 14; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod14 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod14(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)); - } - inline int nargs() { return 14; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod14 : public CppMethod { -public: - typedef void (*Method)(const 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 method_class; - - Const_Pointer_CppMethod14( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13); - return R_NilValue; - } - inline int nargs() { return 14; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod15 : public CppMethod { -public: - typedef RESULT_TYPE (*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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod15(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)); - } - inline int nargs(){ return 15; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod15 : public CppMethod { -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 method_class; - - Pointer_CppMethod15(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14); - return R_NilValue; - } - inline int nargs() { return 15; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod15 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod15(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)); - } - inline int nargs() { return 15; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod15 : public CppMethod { -public: - typedef void (*Method)(const 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 method_class; - - Const_Pointer_CppMethod15( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14); - return R_NilValue; - } - inline int nargs() { return 15; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod16 : public CppMethod { -public: - typedef RESULT_TYPE (*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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod16(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)); - } - inline int nargs(){ return 16; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod16 : public CppMethod { -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 method_class; - - Pointer_CppMethod16(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15); - return R_NilValue; - } - inline int nargs() { return 16; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod16 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod16(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)); - } - inline int nargs() { return 16; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod16 : public CppMethod { -public: - typedef void (*Method)(const 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 method_class; - - Const_Pointer_CppMethod16( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15); - return R_NilValue; - } - inline int nargs() { return 16; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod17 : public CppMethod { -public: - typedef RESULT_TYPE (*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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod17(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)); - } - inline int nargs(){ return 17; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod17 : public CppMethod { -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 method_class; - - Pointer_CppMethod17(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16); - return R_NilValue; - } - inline int nargs() { return 17; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod17 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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 method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod17(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)); - } - inline int nargs() { return 17; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod17 : public CppMethod { -public: - typedef void (*Method)(const 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 method_class; - - Const_Pointer_CppMethod17( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16); - return R_NilValue; - } - inline int nargs() { return 17; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod18 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod18(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)); - } - inline int nargs(){ return 18; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod18 : public CppMethod { -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, U17 u17); - typedef CppMethod method_class; - - Pointer_CppMethod18(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17); - return R_NilValue; - } - inline int nargs() { return 18; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod18 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod18(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)); - } - inline int nargs() { return 18; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod18 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17); - typedef CppMethod method_class; - - Const_Pointer_CppMethod18( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17); - return R_NilValue; - } - inline int nargs() { return 18; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod19 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod19(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)); - } - inline int nargs(){ return 19; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod19 : public CppMethod { -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, U17 u17, U18 u18); - typedef CppMethod method_class; - - Pointer_CppMethod19(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18); - return R_NilValue; - } - inline int nargs() { return 19; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod19 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod19(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)); - } - inline int nargs() { return 19; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod19 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18); - typedef CppMethod method_class; - - Const_Pointer_CppMethod19( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18); - return R_NilValue; - } - inline int nargs() { return 19; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod20 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod20(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)); - } - inline int nargs(){ return 20; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod20 : public CppMethod { -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, U17 u17, U18 u18, U19 u19); - typedef CppMethod method_class; - - Pointer_CppMethod20(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19); - return R_NilValue; - } - inline int nargs() { return 20; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod20 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod20(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)); - } - inline int nargs() { return 20; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod20 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19); - typedef CppMethod method_class; - - Const_Pointer_CppMethod20( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19); - return R_NilValue; - } - inline int nargs() { return 20; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod21 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod21(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)); - } - inline int nargs(){ return 21; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod21 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20); - typedef CppMethod method_class; - - Pointer_CppMethod21(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20); - return R_NilValue; - } - inline int nargs() { return 21; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod21 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod21(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20)); - } - inline int nargs() { return 21; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod21 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20); - typedef CppMethod method_class; - - Const_Pointer_CppMethod21( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20); - return R_NilValue; - } - inline int nargs() { return 21; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod22 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod22(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)); - } - inline int nargs(){ return 22; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod22 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21); - typedef CppMethod method_class; - - Pointer_CppMethod22(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21); - return R_NilValue; - } - inline int nargs() { return 22; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod22 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod22(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21)); - } - inline int nargs() { return 22; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod22 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21); - typedef CppMethod method_class; - - Const_Pointer_CppMethod22( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21); - return R_NilValue; - } - inline int nargs() { return 22; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod23 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod23(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)); - } - inline int nargs(){ return 23; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod23 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22); - typedef CppMethod method_class; - - Pointer_CppMethod23(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22); - return R_NilValue; - } - inline int nargs() { return 23; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod23 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod23(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22)); - } - inline int nargs() { return 23; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod23 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22); - typedef CppMethod method_class; - - Const_Pointer_CppMethod23( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22); - return R_NilValue; - } - inline int nargs() { return 23; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod24 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod24(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23)); - } - inline int nargs(){ return 24; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod24 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23); - typedef CppMethod method_class; - - Pointer_CppMethod24(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23); - return R_NilValue; - } - inline int nargs() { return 24; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod24 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod24(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23)); - } - inline int nargs() { return 24; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod24 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23); - typedef CppMethod method_class; - - Const_Pointer_CppMethod24( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23); - return R_NilValue; - } - inline int nargs() { return 24; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod25 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod25(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24)); - } - inline int nargs(){ return 25; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod25 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24); - typedef CppMethod method_class; - - Pointer_CppMethod25(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24); - return R_NilValue; - } - inline int nargs() { return 25; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod25 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod25(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24)); - } - inline int nargs() { return 25; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod25 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24); - typedef CppMethod method_class; - - Const_Pointer_CppMethod25( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24); - return R_NilValue; - } - inline int nargs() { return 25; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod26 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod26(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25)); - } - inline int nargs(){ return 26; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod26 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25); - typedef CppMethod method_class; - - Pointer_CppMethod26(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25); - return R_NilValue; - } - inline int nargs() { return 26; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod26 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod26(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25)); - } - inline int nargs() { return 26; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod26 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25); - typedef CppMethod method_class; - - Const_Pointer_CppMethod26( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25); - return R_NilValue; - } - inline int nargs() { return 26; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod27 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod27(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26)); - } - inline int nargs(){ return 27; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod27 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26); - typedef CppMethod method_class; - - Pointer_CppMethod27(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26); - return R_NilValue; - } - inline int nargs() { return 27; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod27 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod27(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26)); - } - inline int nargs() { return 27; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod27 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26); - typedef CppMethod method_class; - - Const_Pointer_CppMethod27( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26); - return R_NilValue; - } - inline int nargs() { return 27; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod28 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod28(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27)); - } - inline int nargs(){ return 28; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod28 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27); - typedef CppMethod method_class; - - Pointer_CppMethod28(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27); - return R_NilValue; - } - inline int nargs() { return 28; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod28 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod28(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27)); - } - inline int nargs() { return 28; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod28 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27); - typedef CppMethod method_class; - - Const_Pointer_CppMethod28( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27); - return R_NilValue; - } - inline int nargs() { return 28; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod29 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod29(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28)); - } - inline int nargs(){ return 29; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod29 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28); - typedef CppMethod method_class; - - Pointer_CppMethod29(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28); - return R_NilValue; - } - inline int nargs() { return 29; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod29 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod29(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28)); - } - inline int nargs() { return 29; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod29 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28); - typedef CppMethod method_class; - - Const_Pointer_CppMethod29( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28); - return R_NilValue; - } - inline int nargs() { return 29; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod30 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod30(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29)); - } - inline int nargs(){ return 30; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod30 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29); - typedef CppMethod method_class; - - Pointer_CppMethod30(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29); - return R_NilValue; - } - inline int nargs() { return 30; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod30 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod30(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29)); - } - inline int nargs() { return 30; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod30 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29); - typedef CppMethod method_class; - - Const_Pointer_CppMethod30( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29); - return R_NilValue; - } - inline int nargs() { return 30; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod31 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod31(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30)); - } - inline int nargs(){ return 31; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod31 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30); - typedef CppMethod method_class; - - Pointer_CppMethod31(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30); - return R_NilValue; - } - inline int nargs() { return 31; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod31 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod31(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30)); - } - inline int nargs() { return 31; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod31 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30); - typedef CppMethod method_class; - - Const_Pointer_CppMethod31( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30); - return R_NilValue; - } - inline int nargs() { return 31; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod32 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod32(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31)); - } - inline int nargs(){ return 32; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod32 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31); - typedef CppMethod method_class; - - Pointer_CppMethod32(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31); - return R_NilValue; - } - inline int nargs() { return 32; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod32 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod32(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31)); - } - inline int nargs() { return 32; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod32 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31); - typedef CppMethod method_class; - - Const_Pointer_CppMethod32( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31); - return R_NilValue; - } - inline int nargs() { return 32; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod33 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod33(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32)); - } - inline int nargs(){ return 33; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod33 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32); - typedef CppMethod method_class; - - Pointer_CppMethod33(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32); - return R_NilValue; - } - inline int nargs() { return 33; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod33 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod33(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32)); - } - inline int nargs() { return 33; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod33 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32); - typedef CppMethod method_class; - - Const_Pointer_CppMethod33( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32); - return R_NilValue; - } - inline int nargs() { return 33; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod34 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod34(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33)); - } - inline int nargs(){ return 34; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod34 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33); - typedef CppMethod method_class; - - Pointer_CppMethod34(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33); - return R_NilValue; - } - inline int nargs() { return 34; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod34 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod34(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33)); - } - inline int nargs() { return 34; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod34 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33); - typedef CppMethod method_class; - - Const_Pointer_CppMethod34( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33); - return R_NilValue; - } - inline int nargs() { return 34; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod35 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod35(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34)); - } - inline int nargs(){ return 35; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod35 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34); - typedef CppMethod method_class; - - Pointer_CppMethod35(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34); - return R_NilValue; - } - inline int nargs() { return 35; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod35 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod35(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34)); - } - inline int nargs() { return 35; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod35 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34); - typedef CppMethod method_class; - - Const_Pointer_CppMethod35( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34); - return R_NilValue; - } - inline int nargs() { return 35; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod36 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod36(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35)); - } - inline int nargs(){ return 36; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod36 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35); - typedef CppMethod method_class; - - Pointer_CppMethod36(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35); - return R_NilValue; - } - inline int nargs() { return 36; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod36 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod36(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35)); - } - inline int nargs() { return 36; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod36 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35); - typedef CppMethod method_class; - - Const_Pointer_CppMethod36( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35); - return R_NilValue; - } - inline int nargs() { return 36; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod37 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod37(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36)); - } - inline int nargs(){ return 37; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod37 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36); - typedef CppMethod method_class; - - Pointer_CppMethod37(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36); - return R_NilValue; - } - inline int nargs() { return 37; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod37 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod37(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36)); - } - inline int nargs() { return 37; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod37 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36); - typedef CppMethod method_class; - - Const_Pointer_CppMethod37( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36); - return R_NilValue; - } - inline int nargs() { return 37; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod38 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod38(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37)); - } - inline int nargs(){ return 38; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod38 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37); - typedef CppMethod method_class; - - Pointer_CppMethod38(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37); - return R_NilValue; - } - inline int nargs() { return 38; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod38 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod38(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37)); - } - inline int nargs() { return 38; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod38 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37); - typedef CppMethod method_class; - - Const_Pointer_CppMethod38( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37); - return R_NilValue; - } - inline int nargs() { return 38; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod39 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod39(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38)); - } - inline int nargs(){ return 39; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod39 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38); - typedef CppMethod method_class; - - Pointer_CppMethod39(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38); - return R_NilValue; - } - inline int nargs() { return 39; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod39 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod39(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38)); - } - inline int nargs() { return 39; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod39 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38); - typedef CppMethod method_class; - - Const_Pointer_CppMethod39( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38); - return R_NilValue; - } - inline int nargs() { return 39; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod40 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod40(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39)); - } - inline int nargs(){ return 40; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod40 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39); - typedef CppMethod method_class; - - Pointer_CppMethod40(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39); - return R_NilValue; - } - inline int nargs() { return 40; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod40 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod40(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39)); - } - inline int nargs() { return 40; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod40 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39); - typedef CppMethod method_class; - - Const_Pointer_CppMethod40( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39); - return R_NilValue; - } - inline int nargs() { return 40; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod41 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod41(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40)); - } - inline int nargs(){ return 41; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod41 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40); - typedef CppMethod method_class; - - Pointer_CppMethod41(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40); - return R_NilValue; - } - inline int nargs() { return 41; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod41 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod41(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40)); - } - inline int nargs() { return 41; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod41 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40); - typedef CppMethod method_class; - - Const_Pointer_CppMethod41( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40); - return R_NilValue; - } - inline int nargs() { return 41; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod42 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod42(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41)); - } - inline int nargs(){ return 42; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod42 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41); - typedef CppMethod method_class; - - Pointer_CppMethod42(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41); - return R_NilValue; - } - inline int nargs() { return 42; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod42 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod42(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41)); - } - inline int nargs() { return 42; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod42 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41); - typedef CppMethod method_class; - - Const_Pointer_CppMethod42( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41); - return R_NilValue; - } - inline int nargs() { return 42; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod43 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod43(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42)); - } - inline int nargs(){ return 43; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod43 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42); - typedef CppMethod method_class; - - Pointer_CppMethod43(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42); - return R_NilValue; - } - inline int nargs() { return 43; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod43 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod43(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42)); - } - inline int nargs() { return 43; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod43 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42); - typedef CppMethod method_class; - - Const_Pointer_CppMethod43( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42); - return R_NilValue; - } - inline int nargs() { return 43; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod44 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod44(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43)); - } - inline int nargs(){ return 44; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod44 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43); - typedef CppMethod method_class; - - Pointer_CppMethod44(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43); - return R_NilValue; - } - inline int nargs() { return 44; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod44 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod44(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43)); - } - inline int nargs() { return 44; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod44 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43); - typedef CppMethod method_class; - - Const_Pointer_CppMethod44( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43); - return R_NilValue; - } - inline int nargs() { return 44; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod45 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod45(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44)); - } - inline int nargs(){ return 45; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod45 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44); - typedef CppMethod method_class; - - Pointer_CppMethod45(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44); - return R_NilValue; - } - inline int nargs() { return 45; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod45 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod45(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44)); - } - inline int nargs() { return 45; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod45 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44); - typedef CppMethod method_class; - - Const_Pointer_CppMethod45( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44); - return R_NilValue; - } - inline int nargs() { return 45; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod46 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod46(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45)); - } - inline int nargs(){ return 46; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod46 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45); - typedef CppMethod method_class; - - Pointer_CppMethod46(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45); - return R_NilValue; - } - inline int nargs() { return 46; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod46 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod46(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45)); - } - inline int nargs() { return 46; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod46 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45); - typedef CppMethod method_class; - - Const_Pointer_CppMethod46( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45); - return R_NilValue; - } - inline int nargs() { return 46; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod47 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod47(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46)); - } - inline int nargs(){ return 47; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod47 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46); - typedef CppMethod method_class; - - Pointer_CppMethod47(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46); - return R_NilValue; - } - inline int nargs() { return 47; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod47 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod47(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46)); - } - inline int nargs() { return 47; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod47 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46); - typedef CppMethod method_class; - - Const_Pointer_CppMethod47( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46); - return R_NilValue; - } - inline int nargs() { return 47; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod48 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod48(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47)); - } - inline int nargs(){ return 48; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod48 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47); - typedef CppMethod method_class; - - Pointer_CppMethod48(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47); - return R_NilValue; - } - inline int nargs() { return 48; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod48 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod48(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47)); - } - inline int nargs() { return 48; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod48 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47); - typedef CppMethod method_class; - - Const_Pointer_CppMethod48( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47); - return R_NilValue; - } - inline int nargs() { return 48; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod49 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod49(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48)); - } - inline int nargs(){ return 49; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod49 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48); - typedef CppMethod method_class; - - Pointer_CppMethod49(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48); - return R_NilValue; - } - inline int nargs() { return 49; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod49 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod49(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48)); - } - inline int nargs() { return 49; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod49 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48); - typedef CppMethod method_class; - - Const_Pointer_CppMethod49( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48); - return R_NilValue; - } - inline int nargs() { return 49; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod50 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod50(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49)); - } - inline int nargs(){ return 50; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod50 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49); - typedef CppMethod method_class; - - Pointer_CppMethod50(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49); - return R_NilValue; - } - inline int nargs() { return 50; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod50 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod50(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49)); - } - inline int nargs() { return 50; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod50 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49); - typedef CppMethod method_class; - - Const_Pointer_CppMethod50( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49); - return R_NilValue; - } - inline int nargs() { return 50; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod51 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod51(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50)); - } - inline int nargs(){ return 51; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod51 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50); - typedef CppMethod method_class; - - Pointer_CppMethod51(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50); - return R_NilValue; - } - inline int nargs() { return 51; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod51 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod51(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50)); - } - inline int nargs() { return 51; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod51 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50); - typedef CppMethod method_class; - - Const_Pointer_CppMethod51( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50); - return R_NilValue; - } - inline int nargs() { return 51; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod52 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod52(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51)); - } - inline int nargs(){ return 52; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod52 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51); - typedef CppMethod method_class; - - Pointer_CppMethod52(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51); - return R_NilValue; - } - inline int nargs() { return 52; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod52 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod52(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51)); - } - inline int nargs() { return 52; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod52 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51); - typedef CppMethod method_class; - - Const_Pointer_CppMethod52( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51); - return R_NilValue; - } - inline int nargs() { return 52; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod53 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod53(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52)); - } - inline int nargs(){ return 53; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod53 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52); - typedef CppMethod method_class; - - Pointer_CppMethod53(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52); - return R_NilValue; - } - inline int nargs() { return 53; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod53 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod53(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52)); - } - inline int nargs() { return 53; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod53 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52); - typedef CppMethod method_class; - - Const_Pointer_CppMethod53( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52); - return R_NilValue; - } - inline int nargs() { return 53; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod54 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod54(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53)); - } - inline int nargs(){ return 54; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod54 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53); - typedef CppMethod method_class; - - Pointer_CppMethod54(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53); - return R_NilValue; - } - inline int nargs() { return 54; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod54 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod54(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53)); - } - inline int nargs() { return 54; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod54 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53); - typedef CppMethod method_class; - - Const_Pointer_CppMethod54( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53); - return R_NilValue; - } - inline int nargs() { return 54; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod55 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod55(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54)); - } - inline int nargs(){ return 55; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod55 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54); - typedef CppMethod method_class; - - Pointer_CppMethod55(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54); - return R_NilValue; - } - inline int nargs() { return 55; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod55 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod55(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54)); - } - inline int nargs() { return 55; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod55 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54); - typedef CppMethod method_class; - - Const_Pointer_CppMethod55( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54); - return R_NilValue; - } - inline int nargs() { return 55; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod56 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod56(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55)); - } - inline int nargs(){ return 56; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod56 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55); - typedef CppMethod method_class; - - Pointer_CppMethod56(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55); - return R_NilValue; - } - inline int nargs() { return 56; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod56 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod56(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55)); - } - inline int nargs() { return 56; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod56 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55); - typedef CppMethod method_class; - - Const_Pointer_CppMethod56( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55); - return R_NilValue; - } - inline int nargs() { return 56; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod57 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod57(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56)); - } - inline int nargs(){ return 57; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod57 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56); - typedef CppMethod method_class; - - Pointer_CppMethod57(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56); - return R_NilValue; - } - inline int nargs() { return 57; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod57 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod57(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56)); - } - inline int nargs() { return 57; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod57 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56); - typedef CppMethod method_class; - - Const_Pointer_CppMethod57( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56); - return R_NilValue; - } - inline int nargs() { return 57; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod58 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod58(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57)); - } - inline int nargs(){ return 58; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod58 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57); - typedef CppMethod method_class; - - Pointer_CppMethod58(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57); - return R_NilValue; - } - inline int nargs() { return 58; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod58 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod58(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57)); - } - inline int nargs() { return 58; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod58 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57); - typedef CppMethod method_class; - - Const_Pointer_CppMethod58( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57); - return R_NilValue; - } - inline int nargs() { return 58; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod59 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod59(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58)); - } - inline int nargs(){ return 59; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod59 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58); - typedef CppMethod method_class; - - Pointer_CppMethod59(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58); - return R_NilValue; - } - inline int nargs() { return 59; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod59 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod59(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58)); - } - inline int nargs() { return 59; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod59 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58); - typedef CppMethod method_class; - - Const_Pointer_CppMethod59( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58); - return R_NilValue; - } - inline int nargs() { return 59; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod60 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod60(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59)); - } - inline int nargs(){ return 60; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod60 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59); - typedef CppMethod method_class; - - Pointer_CppMethod60(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59); - return R_NilValue; - } - inline int nargs() { return 60; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod60 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod60(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59)); - } - inline int nargs() { return 60; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod60 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59); - typedef CppMethod method_class; - - Const_Pointer_CppMethod60( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59); - return R_NilValue; - } - inline int nargs() { return 60; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod61 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod61(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60)); - } - inline int nargs(){ return 61; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod61 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60); - typedef CppMethod method_class; - - Pointer_CppMethod61(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60); - return R_NilValue; - } - inline int nargs() { return 61; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod61 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod61(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60)); - } - inline int nargs() { return 61; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod61 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60); - typedef CppMethod method_class; - - Const_Pointer_CppMethod61( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60); - return R_NilValue; - } - inline int nargs() { return 61; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod62 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod62(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61)); - } - inline int nargs(){ return 62; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod62 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61); - typedef CppMethod method_class; - - Pointer_CppMethod62(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61); - return R_NilValue; - } - inline int nargs() { return 62; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod62 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod62(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61)); - } - inline int nargs() { return 62; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod62 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61); - typedef CppMethod method_class; - - Const_Pointer_CppMethod62( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61); - return R_NilValue; - } - inline int nargs() { return 62; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod63 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod63(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62)); - } - inline int nargs(){ return 63; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod63 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62); - typedef CppMethod method_class; - - Pointer_CppMethod63(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62); - return R_NilValue; - } - inline int nargs() { return 63; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod63 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod63(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62)); - } - inline int nargs() { return 63; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod63 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62); - typedef CppMethod method_class; - - Const_Pointer_CppMethod63( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62); - return R_NilValue; - } - inline int nargs() { return 63; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod64 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod64(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63)); - } - inline int nargs(){ return 64; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod64 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63); - typedef CppMethod method_class; - - Pointer_CppMethod64(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63); - return R_NilValue; - } - inline int nargs() { return 64; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod64 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod64(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63)); - } - inline int nargs() { return 64; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod64 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63); - typedef CppMethod method_class; - - Const_Pointer_CppMethod64( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63); - return R_NilValue; - } - inline int nargs() { return 64; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - - -template class Pointer_CppMethod65 : public CppMethod { -public: - typedef RESULT_TYPE (*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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Pointer_CppMethod65(Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; -typename Rcpp::traits::input_parameter< U64 >::type x64( args[64] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64)); - } - inline int nargs(){ return 65; } - inline bool is_void(){ return false; } - inline bool is_const(){ return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Pointer_CppMethod65 : public CppMethod { -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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64); - typedef CppMethod method_class; - - Pointer_CppMethod65(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; -typename Rcpp::traits::input_parameter< U64 >::type x64( args[64] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64); - return R_NilValue; - } - inline int nargs() { return 65; } - inline bool is_void() { return true; } - inline bool is_const() { return false; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -// const - -template class Const_Pointer_CppMethod65 : public CppMethod { -public: - typedef RESULT_TYPE (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64); - typedef CppMethod method_class; - typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; - - Const_Pointer_CppMethod65(Method m) : method_class(), met(m) {} - SEXP operator()(Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; -typename Rcpp::traits::input_parameter< U64 >::type x64( args[64] ) ; - return Rcpp::module_wrap(met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64)); - } - inline int nargs() { return 65; } - inline bool is_void() { return false; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - -template class Const_Pointer_CppMethod65 : public CppMethod { -public: - typedef void (*Method)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64); - typedef CppMethod method_class; - - Const_Pointer_CppMethod65( Method m) : method_class(), met(m) {} - SEXP operator()( Class* object, SEXP* args) { - typename Rcpp::traits::input_parameter< U0 >::type x0( args[0] ) ; -typename Rcpp::traits::input_parameter< U1 >::type x1( args[1] ) ; -typename Rcpp::traits::input_parameter< U2 >::type x2( args[2] ) ; -typename Rcpp::traits::input_parameter< U3 >::type x3( args[3] ) ; -typename Rcpp::traits::input_parameter< U4 >::type x4( args[4] ) ; -typename Rcpp::traits::input_parameter< U5 >::type x5( args[5] ) ; -typename Rcpp::traits::input_parameter< U6 >::type x6( args[6] ) ; -typename Rcpp::traits::input_parameter< U7 >::type x7( args[7] ) ; -typename Rcpp::traits::input_parameter< U8 >::type x8( args[8] ) ; -typename Rcpp::traits::input_parameter< U9 >::type x9( args[9] ) ; -typename Rcpp::traits::input_parameter< U10 >::type x10( args[10] ) ; -typename Rcpp::traits::input_parameter< U11 >::type x11( args[11] ) ; -typename Rcpp::traits::input_parameter< U12 >::type x12( args[12] ) ; -typename Rcpp::traits::input_parameter< U13 >::type x13( args[13] ) ; -typename Rcpp::traits::input_parameter< U14 >::type x14( args[14] ) ; -typename Rcpp::traits::input_parameter< U15 >::type x15( args[15] ) ; -typename Rcpp::traits::input_parameter< U16 >::type x16( args[16] ) ; -typename Rcpp::traits::input_parameter< U17 >::type x17( args[17] ) ; -typename Rcpp::traits::input_parameter< U18 >::type x18( args[18] ) ; -typename Rcpp::traits::input_parameter< U19 >::type x19( args[19] ) ; -typename Rcpp::traits::input_parameter< U20 >::type x20( args[20] ) ; -typename Rcpp::traits::input_parameter< U21 >::type x21( args[21] ) ; -typename Rcpp::traits::input_parameter< U22 >::type x22( args[22] ) ; -typename Rcpp::traits::input_parameter< U23 >::type x23( args[23] ) ; -typename Rcpp::traits::input_parameter< U24 >::type x24( args[24] ) ; -typename Rcpp::traits::input_parameter< U25 >::type x25( args[25] ) ; -typename Rcpp::traits::input_parameter< U26 >::type x26( args[26] ) ; -typename Rcpp::traits::input_parameter< U27 >::type x27( args[27] ) ; -typename Rcpp::traits::input_parameter< U28 >::type x28( args[28] ) ; -typename Rcpp::traits::input_parameter< U29 >::type x29( args[29] ) ; -typename Rcpp::traits::input_parameter< U30 >::type x30( args[30] ) ; -typename Rcpp::traits::input_parameter< U31 >::type x31( args[31] ) ; -typename Rcpp::traits::input_parameter< U32 >::type x32( args[32] ) ; -typename Rcpp::traits::input_parameter< U33 >::type x33( args[33] ) ; -typename Rcpp::traits::input_parameter< U34 >::type x34( args[34] ) ; -typename Rcpp::traits::input_parameter< U35 >::type x35( args[35] ) ; -typename Rcpp::traits::input_parameter< U36 >::type x36( args[36] ) ; -typename Rcpp::traits::input_parameter< U37 >::type x37( args[37] ) ; -typename Rcpp::traits::input_parameter< U38 >::type x38( args[38] ) ; -typename Rcpp::traits::input_parameter< U39 >::type x39( args[39] ) ; -typename Rcpp::traits::input_parameter< U40 >::type x40( args[40] ) ; -typename Rcpp::traits::input_parameter< U41 >::type x41( args[41] ) ; -typename Rcpp::traits::input_parameter< U42 >::type x42( args[42] ) ; -typename Rcpp::traits::input_parameter< U43 >::type x43( args[43] ) ; -typename Rcpp::traits::input_parameter< U44 >::type x44( args[44] ) ; -typename Rcpp::traits::input_parameter< U45 >::type x45( args[45] ) ; -typename Rcpp::traits::input_parameter< U46 >::type x46( args[46] ) ; -typename Rcpp::traits::input_parameter< U47 >::type x47( args[47] ) ; -typename Rcpp::traits::input_parameter< U48 >::type x48( args[48] ) ; -typename Rcpp::traits::input_parameter< U49 >::type x49( args[49] ) ; -typename Rcpp::traits::input_parameter< U50 >::type x50( args[50] ) ; -typename Rcpp::traits::input_parameter< U51 >::type x51( args[51] ) ; -typename Rcpp::traits::input_parameter< U52 >::type x52( args[52] ) ; -typename Rcpp::traits::input_parameter< U53 >::type x53( args[53] ) ; -typename Rcpp::traits::input_parameter< U54 >::type x54( args[54] ) ; -typename Rcpp::traits::input_parameter< U55 >::type x55( args[55] ) ; -typename Rcpp::traits::input_parameter< U56 >::type x56( args[56] ) ; -typename Rcpp::traits::input_parameter< U57 >::type x57( args[57] ) ; -typename Rcpp::traits::input_parameter< U58 >::type x58( args[58] ) ; -typename Rcpp::traits::input_parameter< U59 >::type x59( args[59] ) ; -typename Rcpp::traits::input_parameter< U60 >::type x60( args[60] ) ; -typename Rcpp::traits::input_parameter< U61 >::type x61( args[61] ) ; -typename Rcpp::traits::input_parameter< U62 >::type x62( args[62] ) ; -typename Rcpp::traits::input_parameter< U63 >::type x63( args[63] ) ; -typename Rcpp::traits::input_parameter< U64 >::type x64( args[64] ) ; - met(object, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63, x64); - return R_NilValue; - } - inline int nargs() { return 65; } - inline bool is_void() { return true; } - inline bool is_const() { return true; } - inline void signature(std::string& s, const char* name) { Rcpp::signature(s, name); } - -private: - Method met; -}; - - -#endif - diff --git a/inst/include/Rcpp/module/Module_generated_Pointer_method.h b/inst/include/Rcpp/module/Module_generated_Pointer_method.h deleted file mode 100644 index fb63f72f5..000000000 --- a/inst/include/Rcpp/module/Module_generated_Pointer_method.h +++ /dev/null @@ -1,1017 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// Module_generated_Pointer_method.h: -- generated helper code for Modules -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 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 . - -#ifndef Rcpp_Module_generated_Pointer_method_h -#define Rcpp_Module_generated_Pointer_method_h - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*), - const char* docstring = 0, ValidMethod valid = &yes) { - AddMethod(name_, new Pointer_CppMethod0(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*), - const char* docstring = 0, ValidMethod valid = &yes ){ - AddMethod(name_, new Const_Pointer_CppMethod0( fun ), valid, docstring); - return *this; -} - - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0), - const char* docstring = 0, ValidMethod valid = &yes_arity<1>) { - AddMethod(name_, new Pointer_CppMethod1(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0), - const char* docstring = 0, ValidMethod valid = &yes_arity<1>) { - AddMethod(name_, new Const_Pointer_CppMethod1(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1), - const char* docstring = 0, ValidMethod valid = &yes_arity<2>) { - AddMethod(name_, new Pointer_CppMethod2(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1), - const char* docstring = 0, ValidMethod valid = &yes_arity<2>) { - AddMethod(name_, new Const_Pointer_CppMethod2(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2), - const char* docstring = 0, ValidMethod valid = &yes_arity<3>) { - AddMethod(name_, new Pointer_CppMethod3(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2), - const char* docstring = 0, ValidMethod valid = &yes_arity<3>) { - AddMethod(name_, new Const_Pointer_CppMethod3(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3), - const char* docstring = 0, ValidMethod valid = &yes_arity<4>) { - AddMethod(name_, new Pointer_CppMethod4(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3), - const char* docstring = 0, ValidMethod valid = &yes_arity<4>) { - AddMethod(name_, new Const_Pointer_CppMethod4(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4), - const char* docstring = 0, ValidMethod valid = &yes_arity<5>) { - AddMethod(name_, new Pointer_CppMethod5(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4), - const char* docstring = 0, ValidMethod valid = &yes_arity<5>) { - AddMethod(name_, new Const_Pointer_CppMethod5(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5), - const char* docstring = 0, ValidMethod valid = &yes_arity<6>) { - AddMethod(name_, new Pointer_CppMethod6(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5), - const char* docstring = 0, ValidMethod valid = &yes_arity<6>) { - AddMethod(name_, new Const_Pointer_CppMethod6(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6), - const char* docstring = 0, ValidMethod valid = &yes_arity<7>) { - AddMethod(name_, new Pointer_CppMethod7(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6), - const char* docstring = 0, ValidMethod valid = &yes_arity<7>) { - AddMethod(name_, new Const_Pointer_CppMethod7(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7), - const char* docstring = 0, ValidMethod valid = &yes_arity<8>) { - AddMethod(name_, new Pointer_CppMethod8(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7), - const char* docstring = 0, ValidMethod valid = &yes_arity<8>) { - AddMethod(name_, new Const_Pointer_CppMethod8(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8), - const char* docstring = 0, ValidMethod valid = &yes_arity<9>) { - AddMethod(name_, new Pointer_CppMethod9(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8), - const char* docstring = 0, ValidMethod valid = &yes_arity<9>) { - AddMethod(name_, new Const_Pointer_CppMethod9(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9), - const char* docstring = 0, ValidMethod valid = &yes_arity<10>) { - AddMethod(name_, new Pointer_CppMethod10(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9), - const char* docstring = 0, ValidMethod valid = &yes_arity<10>) { - AddMethod(name_, new Const_Pointer_CppMethod10(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10), - const char* docstring = 0, ValidMethod valid = &yes_arity<11>) { - AddMethod(name_, new Pointer_CppMethod11(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10), - const char* docstring = 0, ValidMethod valid = &yes_arity<11>) { - AddMethod(name_, new Const_Pointer_CppMethod11(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<12>) { - AddMethod(name_, new Pointer_CppMethod12(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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), - const char* docstring = 0, ValidMethod valid = &yes_arity<12>) { - AddMethod(name_, new Const_Pointer_CppMethod12(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<13>) { - AddMethod(name_, new Pointer_CppMethod13(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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), - const char* docstring = 0, ValidMethod valid = &yes_arity<13>) { - AddMethod(name_, new Const_Pointer_CppMethod13(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<14>) { - AddMethod(name_, new Pointer_CppMethod14(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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), - const char* docstring = 0, ValidMethod valid = &yes_arity<14>) { - AddMethod(name_, new Const_Pointer_CppMethod14(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<15>) { - AddMethod(name_, new Pointer_CppMethod15(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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), - const char* docstring = 0, ValidMethod valid = &yes_arity<15>) { - AddMethod(name_, new Const_Pointer_CppMethod15(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<16>) { - AddMethod(name_, new Pointer_CppMethod16(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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), - const char* docstring = 0, ValidMethod valid = &yes_arity<16>) { - AddMethod(name_, new Const_Pointer_CppMethod16(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<17>) { - AddMethod(name_, new Pointer_CppMethod17(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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), - const char* docstring = 0, ValidMethod valid = &yes_arity<17>) { - AddMethod(name_, new Const_Pointer_CppMethod17(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17), - const char* docstring = 0, ValidMethod valid = &yes_arity<18>) { - AddMethod(name_, new Pointer_CppMethod18(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17), - const char* docstring = 0, ValidMethod valid = &yes_arity<18>) { - AddMethod(name_, new Const_Pointer_CppMethod18(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18), - const char* docstring = 0, ValidMethod valid = &yes_arity<19>) { - AddMethod(name_, new Pointer_CppMethod19(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18), - const char* docstring = 0, ValidMethod valid = &yes_arity<19>) { - AddMethod(name_, new Const_Pointer_CppMethod19(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19), - const char* docstring = 0, ValidMethod valid = &yes_arity<20>) { - AddMethod(name_, new Pointer_CppMethod20(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19), - const char* docstring = 0, ValidMethod valid = &yes_arity<20>) { - AddMethod(name_, new Const_Pointer_CppMethod20(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20), - const char* docstring = 0, ValidMethod valid = &yes_arity<21>) { - AddMethod(name_, new Pointer_CppMethod21(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20), - const char* docstring = 0, ValidMethod valid = &yes_arity<21>) { - AddMethod(name_, new Const_Pointer_CppMethod21(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21), - const char* docstring = 0, ValidMethod valid = &yes_arity<22>) { - AddMethod(name_, new Pointer_CppMethod22(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21), - const char* docstring = 0, ValidMethod valid = &yes_arity<22>) { - AddMethod(name_, new Const_Pointer_CppMethod22(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22), - const char* docstring = 0, ValidMethod valid = &yes_arity<23>) { - AddMethod(name_, new Pointer_CppMethod23(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22), - const char* docstring = 0, ValidMethod valid = &yes_arity<23>) { - AddMethod(name_, new Const_Pointer_CppMethod23(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23), - const char* docstring = 0, ValidMethod valid = &yes_arity<24>) { - AddMethod(name_, new Pointer_CppMethod24(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23), - const char* docstring = 0, ValidMethod valid = &yes_arity<24>) { - AddMethod(name_, new Const_Pointer_CppMethod24(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24), - const char* docstring = 0, ValidMethod valid = &yes_arity<25>) { - AddMethod(name_, new Pointer_CppMethod25(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24), - const char* docstring = 0, ValidMethod valid = &yes_arity<25>) { - AddMethod(name_, new Const_Pointer_CppMethod25(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25), - const char* docstring = 0, ValidMethod valid = &yes_arity<26>) { - AddMethod(name_, new Pointer_CppMethod26(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25), - const char* docstring = 0, ValidMethod valid = &yes_arity<26>) { - AddMethod(name_, new Const_Pointer_CppMethod26(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26), - const char* docstring = 0, ValidMethod valid = &yes_arity<27>) { - AddMethod(name_, new Pointer_CppMethod27(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26), - const char* docstring = 0, ValidMethod valid = &yes_arity<27>) { - AddMethod(name_, new Const_Pointer_CppMethod27(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27), - const char* docstring = 0, ValidMethod valid = &yes_arity<28>) { - AddMethod(name_, new Pointer_CppMethod28(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27), - const char* docstring = 0, ValidMethod valid = &yes_arity<28>) { - AddMethod(name_, new Const_Pointer_CppMethod28(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28), - const char* docstring = 0, ValidMethod valid = &yes_arity<29>) { - AddMethod(name_, new Pointer_CppMethod29(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28), - const char* docstring = 0, ValidMethod valid = &yes_arity<29>) { - AddMethod(name_, new Const_Pointer_CppMethod29(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29), - const char* docstring = 0, ValidMethod valid = &yes_arity<30>) { - AddMethod(name_, new Pointer_CppMethod30(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29), - const char* docstring = 0, ValidMethod valid = &yes_arity<30>) { - AddMethod(name_, new Const_Pointer_CppMethod30(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30), - const char* docstring = 0, ValidMethod valid = &yes_arity<31>) { - AddMethod(name_, new Pointer_CppMethod31(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30), - const char* docstring = 0, ValidMethod valid = &yes_arity<31>) { - AddMethod(name_, new Const_Pointer_CppMethod31(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31), - const char* docstring = 0, ValidMethod valid = &yes_arity<32>) { - AddMethod(name_, new Pointer_CppMethod32(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31), - const char* docstring = 0, ValidMethod valid = &yes_arity<32>) { - AddMethod(name_, new Const_Pointer_CppMethod32(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32), - const char* docstring = 0, ValidMethod valid = &yes_arity<33>) { - AddMethod(name_, new Pointer_CppMethod33(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32), - const char* docstring = 0, ValidMethod valid = &yes_arity<33>) { - AddMethod(name_, new Const_Pointer_CppMethod33(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33), - const char* docstring = 0, ValidMethod valid = &yes_arity<34>) { - AddMethod(name_, new Pointer_CppMethod34(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33), - const char* docstring = 0, ValidMethod valid = &yes_arity<34>) { - AddMethod(name_, new Const_Pointer_CppMethod34(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34), - const char* docstring = 0, ValidMethod valid = &yes_arity<35>) { - AddMethod(name_, new Pointer_CppMethod35(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34), - const char* docstring = 0, ValidMethod valid = &yes_arity<35>) { - AddMethod(name_, new Const_Pointer_CppMethod35(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35), - const char* docstring = 0, ValidMethod valid = &yes_arity<36>) { - AddMethod(name_, new Pointer_CppMethod36(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35), - const char* docstring = 0, ValidMethod valid = &yes_arity<36>) { - AddMethod(name_, new Const_Pointer_CppMethod36(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36), - const char* docstring = 0, ValidMethod valid = &yes_arity<37>) { - AddMethod(name_, new Pointer_CppMethod37(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36), - const char* docstring = 0, ValidMethod valid = &yes_arity<37>) { - AddMethod(name_, new Const_Pointer_CppMethod37(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37), - const char* docstring = 0, ValidMethod valid = &yes_arity<38>) { - AddMethod(name_, new Pointer_CppMethod38(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37), - const char* docstring = 0, ValidMethod valid = &yes_arity<38>) { - AddMethod(name_, new Const_Pointer_CppMethod38(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38), - const char* docstring = 0, ValidMethod valid = &yes_arity<39>) { - AddMethod(name_, new Pointer_CppMethod39(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38), - const char* docstring = 0, ValidMethod valid = &yes_arity<39>) { - AddMethod(name_, new Const_Pointer_CppMethod39(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39), - const char* docstring = 0, ValidMethod valid = &yes_arity<40>) { - AddMethod(name_, new Pointer_CppMethod40(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39), - const char* docstring = 0, ValidMethod valid = &yes_arity<40>) { - AddMethod(name_, new Const_Pointer_CppMethod40(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40), - const char* docstring = 0, ValidMethod valid = &yes_arity<41>) { - AddMethod(name_, new Pointer_CppMethod41(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40), - const char* docstring = 0, ValidMethod valid = &yes_arity<41>) { - AddMethod(name_, new Const_Pointer_CppMethod41(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41), - const char* docstring = 0, ValidMethod valid = &yes_arity<42>) { - AddMethod(name_, new Pointer_CppMethod42(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41), - const char* docstring = 0, ValidMethod valid = &yes_arity<42>) { - AddMethod(name_, new Const_Pointer_CppMethod42(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42), - const char* docstring = 0, ValidMethod valid = &yes_arity<43>) { - AddMethod(name_, new Pointer_CppMethod43(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42), - const char* docstring = 0, ValidMethod valid = &yes_arity<43>) { - AddMethod(name_, new Const_Pointer_CppMethod43(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43), - const char* docstring = 0, ValidMethod valid = &yes_arity<44>) { - AddMethod(name_, new Pointer_CppMethod44(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43), - const char* docstring = 0, ValidMethod valid = &yes_arity<44>) { - AddMethod(name_, new Const_Pointer_CppMethod44(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44), - const char* docstring = 0, ValidMethod valid = &yes_arity<45>) { - AddMethod(name_, new Pointer_CppMethod45(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44), - const char* docstring = 0, ValidMethod valid = &yes_arity<45>) { - AddMethod(name_, new Const_Pointer_CppMethod45(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45), - const char* docstring = 0, ValidMethod valid = &yes_arity<46>) { - AddMethod(name_, new Pointer_CppMethod46(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45), - const char* docstring = 0, ValidMethod valid = &yes_arity<46>) { - AddMethod(name_, new Const_Pointer_CppMethod46(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46), - const char* docstring = 0, ValidMethod valid = &yes_arity<47>) { - AddMethod(name_, new Pointer_CppMethod47(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46), - const char* docstring = 0, ValidMethod valid = &yes_arity<47>) { - AddMethod(name_, new Const_Pointer_CppMethod47(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47), - const char* docstring = 0, ValidMethod valid = &yes_arity<48>) { - AddMethod(name_, new Pointer_CppMethod48(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47), - const char* docstring = 0, ValidMethod valid = &yes_arity<48>) { - AddMethod(name_, new Const_Pointer_CppMethod48(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48), - const char* docstring = 0, ValidMethod valid = &yes_arity<49>) { - AddMethod(name_, new Pointer_CppMethod49(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48), - const char* docstring = 0, ValidMethod valid = &yes_arity<49>) { - AddMethod(name_, new Const_Pointer_CppMethod49(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49), - const char* docstring = 0, ValidMethod valid = &yes_arity<50>) { - AddMethod(name_, new Pointer_CppMethod50(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49), - const char* docstring = 0, ValidMethod valid = &yes_arity<50>) { - AddMethod(name_, new Const_Pointer_CppMethod50(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50), - const char* docstring = 0, ValidMethod valid = &yes_arity<51>) { - AddMethod(name_, new Pointer_CppMethod51(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50), - const char* docstring = 0, ValidMethod valid = &yes_arity<51>) { - AddMethod(name_, new Const_Pointer_CppMethod51(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51), - const char* docstring = 0, ValidMethod valid = &yes_arity<52>) { - AddMethod(name_, new Pointer_CppMethod52(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51), - const char* docstring = 0, ValidMethod valid = &yes_arity<52>) { - AddMethod(name_, new Const_Pointer_CppMethod52(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52), - const char* docstring = 0, ValidMethod valid = &yes_arity<53>) { - AddMethod(name_, new Pointer_CppMethod53(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52), - const char* docstring = 0, ValidMethod valid = &yes_arity<53>) { - AddMethod(name_, new Const_Pointer_CppMethod53(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53), - const char* docstring = 0, ValidMethod valid = &yes_arity<54>) { - AddMethod(name_, new Pointer_CppMethod54(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53), - const char* docstring = 0, ValidMethod valid = &yes_arity<54>) { - AddMethod(name_, new Const_Pointer_CppMethod54(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54), - const char* docstring = 0, ValidMethod valid = &yes_arity<55>) { - AddMethod(name_, new Pointer_CppMethod55(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54), - const char* docstring = 0, ValidMethod valid = &yes_arity<55>) { - AddMethod(name_, new Const_Pointer_CppMethod55(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55), - const char* docstring = 0, ValidMethod valid = &yes_arity<56>) { - AddMethod(name_, new Pointer_CppMethod56(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55), - const char* docstring = 0, ValidMethod valid = &yes_arity<56>) { - AddMethod(name_, new Const_Pointer_CppMethod56(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56), - const char* docstring = 0, ValidMethod valid = &yes_arity<57>) { - AddMethod(name_, new Pointer_CppMethod57(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56), - const char* docstring = 0, ValidMethod valid = &yes_arity<57>) { - AddMethod(name_, new Const_Pointer_CppMethod57(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57), - const char* docstring = 0, ValidMethod valid = &yes_arity<58>) { - AddMethod(name_, new Pointer_CppMethod58(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57), - const char* docstring = 0, ValidMethod valid = &yes_arity<58>) { - AddMethod(name_, new Const_Pointer_CppMethod58(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58), - const char* docstring = 0, ValidMethod valid = &yes_arity<59>) { - AddMethod(name_, new Pointer_CppMethod59(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58), - const char* docstring = 0, ValidMethod valid = &yes_arity<59>) { - AddMethod(name_, new Const_Pointer_CppMethod59(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59), - const char* docstring = 0, ValidMethod valid = &yes_arity<60>) { - AddMethod(name_, new Pointer_CppMethod60(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59), - const char* docstring = 0, ValidMethod valid = &yes_arity<60>) { - AddMethod(name_, new Const_Pointer_CppMethod60(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60), - const char* docstring = 0, ValidMethod valid = &yes_arity<61>) { - AddMethod(name_, new Pointer_CppMethod61(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60), - const char* docstring = 0, ValidMethod valid = &yes_arity<61>) { - AddMethod(name_, new Const_Pointer_CppMethod61(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61), - const char* docstring = 0, ValidMethod valid = &yes_arity<62>) { - AddMethod(name_, new Pointer_CppMethod62(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61), - const char* docstring = 0, ValidMethod valid = &yes_arity<62>) { - AddMethod(name_, new Const_Pointer_CppMethod62(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62), - const char* docstring = 0, ValidMethod valid = &yes_arity<63>) { - AddMethod(name_, new Pointer_CppMethod63(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62), - const char* docstring = 0, ValidMethod valid = &yes_arity<63>) { - AddMethod(name_, new Const_Pointer_CppMethod63(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63), - const char* docstring = 0, ValidMethod valid = &yes_arity<64>) { - AddMethod(name_, new Pointer_CppMethod64(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63), - const char* docstring = 0, ValidMethod valid = &yes_arity<64>) { - AddMethod(name_, new Const_Pointer_CppMethod64(fun), valid, docstring); - return *this ; -} - - -template -self& method(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64), - const char* docstring = 0, ValidMethod valid = &yes_arity<65>) { - AddMethod(name_, new Pointer_CppMethod65(fun), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (*fun)(const 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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64), - const char* docstring = 0, ValidMethod valid = &yes_arity<65>) { - AddMethod(name_, new Const_Pointer_CppMethod65(fun), valid, docstring); - return *this ; -} - -#endif - diff --git a/inst/include/Rcpp/module/Module_generated_class_constructor.h b/inst/include/Rcpp/module/Module_generated_class_constructor.h deleted file mode 100644 index 39aff662e..000000000 --- a/inst/include/Rcpp/module/Module_generated_class_constructor.h +++ /dev/null @@ -1,108 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Module_generated_class_constructor.h: Rcpp R/C++ interface class library -- Rcpp modules -// -// Copyright (C) 2010 - 2011 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 . - -#ifndef Rcpp_Module_generated_class_constructor_h -#define Rcpp_Module_generated_class_constructor_h - - template < - typename U0, - typename U1, - typename U2, - typename U3, - typename U4, - typename U5, - typename U6 - > - self& constructor( const char* docstring = 0, ValidConstructor valid = &yes_arity<7> ){ - AddConstructor( new Constructor_7 , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1, - typename U2, - typename U3, - typename U4, - typename U5 - > - self& constructor( const char* docstring = 0, ValidConstructor valid = &yes_arity<6> ){ - AddConstructor( new Constructor_6 , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1, - typename U2, - typename U3, - typename U4 - > - self& constructor( const char* docstring = 0, ValidConstructor valid = &yes_arity<5>){ - AddConstructor( new Constructor_5 , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1, - typename U2, - typename U3 - > - self& constructor( const char* docstring="", ValidConstructor valid = &yes_arity<4>){ - AddConstructor( new Constructor_4 , valid, docstring ) ; - return *this ; - } - - - template < - typename U0, - typename U1, - typename U2 - > - self& constructor( const char* docstring="", ValidConstructor valid = &yes_arity<3>){ - AddConstructor( new Constructor_3 , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1 - > - self& constructor( const char* docstring="", ValidConstructor valid = &yes_arity<2>){ - AddConstructor( new Constructor_2 , valid, docstring ) ; - return *this ; - } - - template < - typename U0 - > - self& constructor( const char* docstring="", ValidConstructor valid = &yes_arity<1>){ - AddConstructor( new Constructor_1 , valid, docstring ) ; - return *this ; - } - - self& constructor( const char* docstring="", ValidConstructor valid = &yes_arity<0>){ - AddConstructor( new Constructor_0, valid , docstring) ; - return *this ; - } - -#endif diff --git a/inst/include/Rcpp/module/Module_generated_class_factory.h b/inst/include/Rcpp/module/Module_generated_class_factory.h deleted file mode 100644 index adcf70535..000000000 --- a/inst/include/Rcpp/module/Module_generated_class_factory.h +++ /dev/null @@ -1,108 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Module_generated_class_factory.h: Rcpp R/C++ interface class library -- alternative way to declare constructors -// -// Copyright (C) 2012 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 . - -#ifndef Rcpp_Module_generated_class_factory_h -#define Rcpp_Module_generated_class_factory_h - - template < - typename U0, - typename U1, - typename U2, - typename U3, - typename U4, - typename U5, - typename U6 - > - self& factory( Class* (*fun)(U0,U1,U2,U3,U4,U5,U6), const char* docstring = 0, ValidConstructor valid = &yes_arity<7> ){ - AddFactory( new Factory_7(fun) , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1, - typename U2, - typename U3, - typename U4, - typename U5 - > - self& factory( Class* (*fun)(U0,U1,U2,U3,U4,U5), const char* docstring = 0, ValidConstructor valid = &yes_arity<6> ){ - AddFactory( new Factory_6(fun) , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1, - typename U2, - typename U3, - typename U4 - > - self& factory( Class* (*fun)(U0,U1,U2,U3,U4), const char* docstring = 0, ValidConstructor valid = &yes_arity<5>){ - AddFactory( new Factory_5(fun) , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1, - typename U2, - typename U3 - > - self& factory( Class* (*fun)(U0,U1,U2,U3), const char* docstring="", ValidConstructor valid = &yes_arity<4>){ - AddFactory( new Factory_4(fun) , valid, docstring ) ; - return *this ; - } - - - template < - typename U0, - typename U1, - typename U2 - > - self& factory( Class* (*fun)(U0,U1,U2), const char* docstring="", ValidConstructor valid = &yes_arity<3>){ - AddFactory( new Factory_3(fun) , valid, docstring ) ; - return *this ; - } - - template < - typename U0, - typename U1 - > - self& factory( Class* (*fun)(U0,U1), const char* docstring="", ValidConstructor valid = &yes_arity<2>){ - AddFactory( new Factory_2(fun) , valid, docstring ) ; - return *this ; - } - - template < - typename U0 - > - self& factory( Class* (*fun)(U0), const char* docstring="", ValidConstructor valid = &yes_arity<1>){ - AddFactory( new Factory_1(fun) , valid, docstring ) ; - return *this ; - } - - self& factory( Class* (*fun)(void), const char* docstring="", ValidConstructor valid = &yes_arity<0>){ - AddFactory( new Factory_0(fun), valid , docstring) ; - return *this ; - } - -#endif diff --git a/inst/include/Rcpp/module/Module_generated_ctor_signature.h b/inst/include/Rcpp/module/Module_generated_ctor_signature.h deleted file mode 100644 index 27a45ba0f..000000000 --- a/inst/include/Rcpp/module/Module_generated_ctor_signature.h +++ /dev/null @@ -1,108 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 4 -*- -// -// Module_generated_ctor_signature.h: Rcpp R/C++ interface class library -- -// -// Copyright (C) 2010 - 2011 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 . - -#ifndef Rcpp_Module_generated_ctor_signature_h -#define Rcpp_Module_generated_ctor_signature_h - -inline void ctor_signature( std::string& s, const std::string& classname){ - s.assign(classname) ; - s+= "()" ; -} - -template -inline void ctor_signature( std::string& s, const std::string& classname ){ - s.assign(classname) ; - s += "(" ; - s += get_return_type() ; - s += ")" ; -} - -template -inline void ctor_signature( std::string& s, const std::string& classname ){ - s.assign(classname) ; - s += "(" ; - s += get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ")" ; -} - -template -inline void ctor_signature( std::string& s, const std::string& classname ){ - s.assign(classname) ; - s += "(" ; - s += get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ")" ; -} - -template -inline void ctor_signature( std::string& s, const std::string& classname ){ - s.assign(classname) ; - s += "(" ; - s += get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ")" ; -} - -template -inline void ctor_signature( std::string& s, const std::string& classname ){ - s.assign(classname) ; - s += "(" ; - s += get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ")" ; -} - -template -inline void ctor_signature( std::string& s, const std::string& classname ){ - s.assign(classname) ; - s += "(" ; - s += get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ")" ; -} - -template -inline void ctor_signature( std::string& s, const std::string& classname ){ - s.assign(classname) ; - s += "(" ; - s += get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ", " ; s+= get_return_type() ; - s += ")" ; -} - - -#endif diff --git a/inst/include/Rcpp/module/Module_generated_function.h b/inst/include/Rcpp/module/Module_generated_function.h deleted file mode 100644 index 803b02bca..000000000 --- a/inst/include/Rcpp/module/Module_generated_function.h +++ /dev/null @@ -1,1087 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// Module_generated_function.h: -- generated helper code for Modules -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 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 . - -#ifndef Rcpp_Module_generated_function_h -#define Rcpp_Module_generated_function_h - -namespace Rcpp { - - -template -void function(const char* name_, RESULT_TYPE (*fun)(void), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction0(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(void), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals0(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction1(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals1(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction2(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals2(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction3(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals3(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction4(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals4(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction5(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals5(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction6(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals6(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction7(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals7(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction8(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals8(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction9(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals9(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction10(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals10(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction11(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals11(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction12(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals12(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction13(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals13(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction14(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals14(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction15(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals15(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction16(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals16(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction17(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals17(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction18(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals18(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction19(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals19(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction20(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals20(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction21(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals21(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction22(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals22(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction23(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals23(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction24(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals24(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction25(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals25(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction26(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals26(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction27(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals27(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction28(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals28(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction29(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals29(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction30(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals30(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction31(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals31(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction32(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals32(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction33(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals33(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction34(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals34(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction35(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals35(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction36(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals36(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction37(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals37(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction38(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals38(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction39(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals39(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction40(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals40(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction41(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals41(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction42(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals42(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction43(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals43(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction44(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals44(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction45(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals45(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction46(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals46(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction47(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals47(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction48(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals48(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction49(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals49(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction50(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals50(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction51(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals51(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction52(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals52(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction53(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals53(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction54(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals54(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction55(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals55(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction56(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals56(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction57(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals57(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction58(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals58(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction59(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals59(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction60(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals60(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction61(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals61(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction62(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals62(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction63(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals63(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction64(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals64(fun, formals, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64), const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction65(fun, docstring)); - } -} - -template -void function(const char* name_, RESULT_TYPE (*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64), Rcpp::List formals, const char* docstring = 0) { - Rcpp::Module* scope = ::getCurrentScope(); - if (scope) { - scope->Add(name_, new CppFunction_WithFormals65(fun, formals, docstring)); - } -} - -} - -#endif diff --git a/inst/include/Rcpp/module/Module_generated_get_signature.h b/inst/include/Rcpp/module/Module_generated_get_signature.h deleted file mode 100644 index d151e0d45..000000000 --- a/inst/include/Rcpp/module/Module_generated_get_signature.h +++ /dev/null @@ -1,3106 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// Module_generated_get_signature.h: -- generated helper code for Modules -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 Doug Bates, 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 . - -#ifndef Rcpp_Module_generated_get_signature_h -#define Rcpp_Module_generated_get_signature_h - -namespace Rcpp { - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "()"; -} - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ")"; -} - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - - -template -inline void signature(std::string& s, const char* name) { - s.clear(); - s += get_return_type(); - s += " "; - s += name; - s += "("; - s += get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ", "; s+= get_return_type(); - s += ")"; -} - - - -} - -#endif diff --git a/inst/include/Rcpp/module/Module_generated_method.h b/inst/include/Rcpp/module/Module_generated_method.h deleted file mode 100644 index 4f3cc1a99..000000000 --- a/inst/include/Rcpp/module/Module_generated_method.h +++ /dev/null @@ -1,1941 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// Module_generated_method.h: -- generated helper code for Modules -// see rcpp-scripts repo for generator script -// -// Copyright (C) 2010 - 2014 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 . - -#ifndef Rcpp_Module_generated_method_h -#define Rcpp_Module_generated_method_h - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(void), - const char* docstring = 0, ValidMethod valid = &yes) { - AddMethod(name_, new CppMethod0(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(void) const, - const char* docstring = 0, ValidMethod valid = &yes) { - AddMethod( name_, new const_CppMethod0(fun), valid, docstring); - return *this; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(void), - const char* docstring = 0, ValidMethod valid = &yes ){ - AddMethod( name_, new CppMethod0( fun ) , valid, docstring ) ; - return *this ; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(void) const, - const char* docstring = 0, ValidMethod valid = &yes ){ - AddMethod( name_, new const_CppMethod0( fun ), valid, docstring ) ; - return *this ; -} - - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0), - const char* docstring = 0, ValidMethod valid = &yes_arity<1>) { - AddMethod( name_, new CppMethod1(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<1>) { - AddMethod(name_, new const_CppMethod1(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0), - const char* docstring = 0, ValidMethod valid = &yes_arity<1>) { - AddMethod(name_, new CppMethod1( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<1>) { - AddMethod(name_, new const_CppMethod1( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1), - const char* docstring = 0, ValidMethod valid = &yes_arity<2>) { - AddMethod( name_, new CppMethod2(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<2>) { - AddMethod(name_, new const_CppMethod2(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1), - const char* docstring = 0, ValidMethod valid = &yes_arity<2>) { - AddMethod(name_, new CppMethod2( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<2>) { - AddMethod(name_, new const_CppMethod2( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2), - const char* docstring = 0, ValidMethod valid = &yes_arity<3>) { - AddMethod( name_, new CppMethod3(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<3>) { - AddMethod(name_, new const_CppMethod3(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2), - const char* docstring = 0, ValidMethod valid = &yes_arity<3>) { - AddMethod(name_, new CppMethod3( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<3>) { - AddMethod(name_, new const_CppMethod3( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3), - const char* docstring = 0, ValidMethod valid = &yes_arity<4>) { - AddMethod( name_, new CppMethod4(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<4>) { - AddMethod(name_, new const_CppMethod4(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3), - const char* docstring = 0, ValidMethod valid = &yes_arity<4>) { - AddMethod(name_, new CppMethod4( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<4>) { - AddMethod(name_, new const_CppMethod4( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4), - const char* docstring = 0, ValidMethod valid = &yes_arity<5>) { - AddMethod( name_, new CppMethod5(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<5>) { - AddMethod(name_, new const_CppMethod5(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4), - const char* docstring = 0, ValidMethod valid = &yes_arity<5>) { - AddMethod(name_, new CppMethod5( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<5>) { - AddMethod(name_, new const_CppMethod5( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5), - const char* docstring = 0, ValidMethod valid = &yes_arity<6>) { - AddMethod( name_, new CppMethod6(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<6>) { - AddMethod(name_, new const_CppMethod6(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5), - const char* docstring = 0, ValidMethod valid = &yes_arity<6>) { - AddMethod(name_, new CppMethod6( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<6>) { - AddMethod(name_, new const_CppMethod6( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6), - const char* docstring = 0, ValidMethod valid = &yes_arity<7>) { - AddMethod( name_, new CppMethod7(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<7>) { - AddMethod(name_, new const_CppMethod7(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6), - const char* docstring = 0, ValidMethod valid = &yes_arity<7>) { - AddMethod(name_, new CppMethod7( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<7>) { - AddMethod(name_, new const_CppMethod7( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7), - const char* docstring = 0, ValidMethod valid = &yes_arity<8>) { - AddMethod( name_, new CppMethod8(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<8>) { - AddMethod(name_, new const_CppMethod8(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7), - const char* docstring = 0, ValidMethod valid = &yes_arity<8>) { - AddMethod(name_, new CppMethod8( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<8>) { - AddMethod(name_, new const_CppMethod8( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8), - const char* docstring = 0, ValidMethod valid = &yes_arity<9>) { - AddMethod( name_, new CppMethod9(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<9>) { - AddMethod(name_, new const_CppMethod9(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8), - const char* docstring = 0, ValidMethod valid = &yes_arity<9>) { - AddMethod(name_, new CppMethod9( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<9>) { - AddMethod(name_, new const_CppMethod9( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9), - const char* docstring = 0, ValidMethod valid = &yes_arity<10>) { - AddMethod( name_, new CppMethod10(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<10>) { - AddMethod(name_, new const_CppMethod10(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9), - const char* docstring = 0, ValidMethod valid = &yes_arity<10>) { - AddMethod(name_, new CppMethod10( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<10>) { - AddMethod(name_, new const_CppMethod10( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10), - const char* docstring = 0, ValidMethod valid = &yes_arity<11>) { - AddMethod( name_, new CppMethod11(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<11>) { - AddMethod(name_, new const_CppMethod11(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10), - const char* docstring = 0, ValidMethod valid = &yes_arity<11>) { - AddMethod(name_, new CppMethod11( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<11>) { - AddMethod(name_, new const_CppMethod11( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11), - const char* docstring = 0, ValidMethod valid = &yes_arity<12>) { - AddMethod( name_, new CppMethod12(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<12>) { - AddMethod(name_, new const_CppMethod12(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11), - const char* docstring = 0, ValidMethod valid = &yes_arity<12>) { - AddMethod(name_, new CppMethod12( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5, U6 u6, U7 u7, U8 u8, U9 u9, U10 u10, U11 u11) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<12>) { - AddMethod(name_, new const_CppMethod12( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<13>) { - AddMethod( name_, new CppMethod13(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<13>) { - AddMethod(name_, new const_CppMethod13(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<13>) { - AddMethod(name_, new CppMethod13( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<13>) { - AddMethod(name_, new const_CppMethod13( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<14>) { - AddMethod( name_, new CppMethod14(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<14>) { - AddMethod(name_, new const_CppMethod14(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<14>) { - AddMethod(name_, new CppMethod14( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<14>) { - AddMethod(name_, new const_CppMethod14( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<15>) { - AddMethod( name_, new CppMethod15(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<15>) { - AddMethod(name_, new const_CppMethod15(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<15>) { - AddMethod(name_, new CppMethod15( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<15>) { - AddMethod(name_, new const_CppMethod15( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<16>) { - AddMethod( name_, new CppMethod16(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<16>) { - AddMethod(name_, new const_CppMethod16(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<16>) { - AddMethod(name_, new CppMethod16( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<16>) { - AddMethod(name_, new const_CppMethod16( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<17>) { - AddMethod( name_, new CppMethod17(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<17>) { - AddMethod(name_, new const_CppMethod17(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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), - const char* docstring = 0, ValidMethod valid = &yes_arity<17>) { - AddMethod(name_, new CppMethod17( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<17>) { - AddMethod(name_, new const_CppMethod17( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17), - const char* docstring = 0, ValidMethod valid = &yes_arity<18>) { - AddMethod( name_, new CppMethod18(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<18>) { - AddMethod(name_, new const_CppMethod18(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17), - const char* docstring = 0, ValidMethod valid = &yes_arity<18>) { - AddMethod(name_, new CppMethod18( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<18>) { - AddMethod(name_, new const_CppMethod18( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18), - const char* docstring = 0, ValidMethod valid = &yes_arity<19>) { - AddMethod( name_, new CppMethod19(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<19>) { - AddMethod(name_, new const_CppMethod19(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18), - const char* docstring = 0, ValidMethod valid = &yes_arity<19>) { - AddMethod(name_, new CppMethod19( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<19>) { - AddMethod(name_, new const_CppMethod19( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19), - const char* docstring = 0, ValidMethod valid = &yes_arity<20>) { - AddMethod( name_, new CppMethod20(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<20>) { - AddMethod(name_, new const_CppMethod20(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19), - const char* docstring = 0, ValidMethod valid = &yes_arity<20>) { - AddMethod(name_, new CppMethod20( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<20>) { - AddMethod(name_, new const_CppMethod20( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20), - const char* docstring = 0, ValidMethod valid = &yes_arity<21>) { - AddMethod( name_, new CppMethod21(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<21>) { - AddMethod(name_, new const_CppMethod21(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20), - const char* docstring = 0, ValidMethod valid = &yes_arity<21>) { - AddMethod(name_, new CppMethod21( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<21>) { - AddMethod(name_, new const_CppMethod21( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21), - const char* docstring = 0, ValidMethod valid = &yes_arity<22>) { - AddMethod( name_, new CppMethod22(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<22>) { - AddMethod(name_, new const_CppMethod22(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21), - const char* docstring = 0, ValidMethod valid = &yes_arity<22>) { - AddMethod(name_, new CppMethod22( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<22>) { - AddMethod(name_, new const_CppMethod22( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22), - const char* docstring = 0, ValidMethod valid = &yes_arity<23>) { - AddMethod( name_, new CppMethod23(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<23>) { - AddMethod(name_, new const_CppMethod23(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22), - const char* docstring = 0, ValidMethod valid = &yes_arity<23>) { - AddMethod(name_, new CppMethod23( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<23>) { - AddMethod(name_, new const_CppMethod23( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23), - const char* docstring = 0, ValidMethod valid = &yes_arity<24>) { - AddMethod( name_, new CppMethod24(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<24>) { - AddMethod(name_, new const_CppMethod24(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23), - const char* docstring = 0, ValidMethod valid = &yes_arity<24>) { - AddMethod(name_, new CppMethod24( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<24>) { - AddMethod(name_, new const_CppMethod24( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24), - const char* docstring = 0, ValidMethod valid = &yes_arity<25>) { - AddMethod( name_, new CppMethod25(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<25>) { - AddMethod(name_, new const_CppMethod25(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24), - const char* docstring = 0, ValidMethod valid = &yes_arity<25>) { - AddMethod(name_, new CppMethod25( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<25>) { - AddMethod(name_, new const_CppMethod25( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25), - const char* docstring = 0, ValidMethod valid = &yes_arity<26>) { - AddMethod( name_, new CppMethod26(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<26>) { - AddMethod(name_, new const_CppMethod26(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25), - const char* docstring = 0, ValidMethod valid = &yes_arity<26>) { - AddMethod(name_, new CppMethod26( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<26>) { - AddMethod(name_, new const_CppMethod26( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26), - const char* docstring = 0, ValidMethod valid = &yes_arity<27>) { - AddMethod( name_, new CppMethod27(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<27>) { - AddMethod(name_, new const_CppMethod27(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26), - const char* docstring = 0, ValidMethod valid = &yes_arity<27>) { - AddMethod(name_, new CppMethod27( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<27>) { - AddMethod(name_, new const_CppMethod27( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27), - const char* docstring = 0, ValidMethod valid = &yes_arity<28>) { - AddMethod( name_, new CppMethod28(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<28>) { - AddMethod(name_, new const_CppMethod28(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27), - const char* docstring = 0, ValidMethod valid = &yes_arity<28>) { - AddMethod(name_, new CppMethod28( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<28>) { - AddMethod(name_, new const_CppMethod28( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28), - const char* docstring = 0, ValidMethod valid = &yes_arity<29>) { - AddMethod( name_, new CppMethod29(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<29>) { - AddMethod(name_, new const_CppMethod29(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28), - const char* docstring = 0, ValidMethod valid = &yes_arity<29>) { - AddMethod(name_, new CppMethod29( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<29>) { - AddMethod(name_, new const_CppMethod29( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29), - const char* docstring = 0, ValidMethod valid = &yes_arity<30>) { - AddMethod( name_, new CppMethod30(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<30>) { - AddMethod(name_, new const_CppMethod30(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29), - const char* docstring = 0, ValidMethod valid = &yes_arity<30>) { - AddMethod(name_, new CppMethod30( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<30>) { - AddMethod(name_, new const_CppMethod30( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30), - const char* docstring = 0, ValidMethod valid = &yes_arity<31>) { - AddMethod( name_, new CppMethod31(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<31>) { - AddMethod(name_, new const_CppMethod31(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30), - const char* docstring = 0, ValidMethod valid = &yes_arity<31>) { - AddMethod(name_, new CppMethod31( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<31>) { - AddMethod(name_, new const_CppMethod31( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31), - const char* docstring = 0, ValidMethod valid = &yes_arity<32>) { - AddMethod( name_, new CppMethod32(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<32>) { - AddMethod(name_, new const_CppMethod32(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31), - const char* docstring = 0, ValidMethod valid = &yes_arity<32>) { - AddMethod(name_, new CppMethod32( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<32>) { - AddMethod(name_, new const_CppMethod32( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32), - const char* docstring = 0, ValidMethod valid = &yes_arity<33>) { - AddMethod( name_, new CppMethod33(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<33>) { - AddMethod(name_, new const_CppMethod33(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32), - const char* docstring = 0, ValidMethod valid = &yes_arity<33>) { - AddMethod(name_, new CppMethod33( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<33>) { - AddMethod(name_, new const_CppMethod33( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33), - const char* docstring = 0, ValidMethod valid = &yes_arity<34>) { - AddMethod( name_, new CppMethod34(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<34>) { - AddMethod(name_, new const_CppMethod34(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33), - const char* docstring = 0, ValidMethod valid = &yes_arity<34>) { - AddMethod(name_, new CppMethod34( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<34>) { - AddMethod(name_, new const_CppMethod34( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34), - const char* docstring = 0, ValidMethod valid = &yes_arity<35>) { - AddMethod( name_, new CppMethod35(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<35>) { - AddMethod(name_, new const_CppMethod35(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34), - const char* docstring = 0, ValidMethod valid = &yes_arity<35>) { - AddMethod(name_, new CppMethod35( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<35>) { - AddMethod(name_, new const_CppMethod35( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35), - const char* docstring = 0, ValidMethod valid = &yes_arity<36>) { - AddMethod( name_, new CppMethod36(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<36>) { - AddMethod(name_, new const_CppMethod36(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35), - const char* docstring = 0, ValidMethod valid = &yes_arity<36>) { - AddMethod(name_, new CppMethod36( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<36>) { - AddMethod(name_, new const_CppMethod36( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36), - const char* docstring = 0, ValidMethod valid = &yes_arity<37>) { - AddMethod( name_, new CppMethod37(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<37>) { - AddMethod(name_, new const_CppMethod37(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36), - const char* docstring = 0, ValidMethod valid = &yes_arity<37>) { - AddMethod(name_, new CppMethod37( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<37>) { - AddMethod(name_, new const_CppMethod37( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37), - const char* docstring = 0, ValidMethod valid = &yes_arity<38>) { - AddMethod( name_, new CppMethod38(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<38>) { - AddMethod(name_, new const_CppMethod38(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37), - const char* docstring = 0, ValidMethod valid = &yes_arity<38>) { - AddMethod(name_, new CppMethod38( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<38>) { - AddMethod(name_, new const_CppMethod38( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38), - const char* docstring = 0, ValidMethod valid = &yes_arity<39>) { - AddMethod( name_, new CppMethod39(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<39>) { - AddMethod(name_, new const_CppMethod39(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38), - const char* docstring = 0, ValidMethod valid = &yes_arity<39>) { - AddMethod(name_, new CppMethod39( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<39>) { - AddMethod(name_, new const_CppMethod39( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39), - const char* docstring = 0, ValidMethod valid = &yes_arity<40>) { - AddMethod( name_, new CppMethod40(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<40>) { - AddMethod(name_, new const_CppMethod40(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39), - const char* docstring = 0, ValidMethod valid = &yes_arity<40>) { - AddMethod(name_, new CppMethod40( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<40>) { - AddMethod(name_, new const_CppMethod40( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40), - const char* docstring = 0, ValidMethod valid = &yes_arity<41>) { - AddMethod( name_, new CppMethod41(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<41>) { - AddMethod(name_, new const_CppMethod41(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40), - const char* docstring = 0, ValidMethod valid = &yes_arity<41>) { - AddMethod(name_, new CppMethod41( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<41>) { - AddMethod(name_, new const_CppMethod41( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41), - const char* docstring = 0, ValidMethod valid = &yes_arity<42>) { - AddMethod( name_, new CppMethod42(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<42>) { - AddMethod(name_, new const_CppMethod42(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41), - const char* docstring = 0, ValidMethod valid = &yes_arity<42>) { - AddMethod(name_, new CppMethod42( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<42>) { - AddMethod(name_, new const_CppMethod42( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42), - const char* docstring = 0, ValidMethod valid = &yes_arity<43>) { - AddMethod( name_, new CppMethod43(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<43>) { - AddMethod(name_, new const_CppMethod43(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42), - const char* docstring = 0, ValidMethod valid = &yes_arity<43>) { - AddMethod(name_, new CppMethod43( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<43>) { - AddMethod(name_, new const_CppMethod43( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43), - const char* docstring = 0, ValidMethod valid = &yes_arity<44>) { - AddMethod( name_, new CppMethod44(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<44>) { - AddMethod(name_, new const_CppMethod44(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43), - const char* docstring = 0, ValidMethod valid = &yes_arity<44>) { - AddMethod(name_, new CppMethod44( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<44>) { - AddMethod(name_, new const_CppMethod44( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44), - const char* docstring = 0, ValidMethod valid = &yes_arity<45>) { - AddMethod( name_, new CppMethod45(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<45>) { - AddMethod(name_, new const_CppMethod45(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44), - const char* docstring = 0, ValidMethod valid = &yes_arity<45>) { - AddMethod(name_, new CppMethod45( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<45>) { - AddMethod(name_, new const_CppMethod45( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45), - const char* docstring = 0, ValidMethod valid = &yes_arity<46>) { - AddMethod( name_, new CppMethod46(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<46>) { - AddMethod(name_, new const_CppMethod46(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45), - const char* docstring = 0, ValidMethod valid = &yes_arity<46>) { - AddMethod(name_, new CppMethod46( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<46>) { - AddMethod(name_, new const_CppMethod46( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46), - const char* docstring = 0, ValidMethod valid = &yes_arity<47>) { - AddMethod( name_, new CppMethod47(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<47>) { - AddMethod(name_, new const_CppMethod47(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46), - const char* docstring = 0, ValidMethod valid = &yes_arity<47>) { - AddMethod(name_, new CppMethod47( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<47>) { - AddMethod(name_, new const_CppMethod47( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47), - const char* docstring = 0, ValidMethod valid = &yes_arity<48>) { - AddMethod( name_, new CppMethod48(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<48>) { - AddMethod(name_, new const_CppMethod48(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47), - const char* docstring = 0, ValidMethod valid = &yes_arity<48>) { - AddMethod(name_, new CppMethod48( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<48>) { - AddMethod(name_, new const_CppMethod48( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48), - const char* docstring = 0, ValidMethod valid = &yes_arity<49>) { - AddMethod( name_, new CppMethod49(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<49>) { - AddMethod(name_, new const_CppMethod49(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48), - const char* docstring = 0, ValidMethod valid = &yes_arity<49>) { - AddMethod(name_, new CppMethod49( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<49>) { - AddMethod(name_, new const_CppMethod49( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49), - const char* docstring = 0, ValidMethod valid = &yes_arity<50>) { - AddMethod( name_, new CppMethod50(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<50>) { - AddMethod(name_, new const_CppMethod50(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49), - const char* docstring = 0, ValidMethod valid = &yes_arity<50>) { - AddMethod(name_, new CppMethod50( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<50>) { - AddMethod(name_, new const_CppMethod50( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50), - const char* docstring = 0, ValidMethod valid = &yes_arity<51>) { - AddMethod( name_, new CppMethod51(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<51>) { - AddMethod(name_, new const_CppMethod51(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50), - const char* docstring = 0, ValidMethod valid = &yes_arity<51>) { - AddMethod(name_, new CppMethod51( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<51>) { - AddMethod(name_, new const_CppMethod51( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51), - const char* docstring = 0, ValidMethod valid = &yes_arity<52>) { - AddMethod( name_, new CppMethod52(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<52>) { - AddMethod(name_, new const_CppMethod52(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51), - const char* docstring = 0, ValidMethod valid = &yes_arity<52>) { - AddMethod(name_, new CppMethod52( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<52>) { - AddMethod(name_, new const_CppMethod52( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52), - const char* docstring = 0, ValidMethod valid = &yes_arity<53>) { - AddMethod( name_, new CppMethod53(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<53>) { - AddMethod(name_, new const_CppMethod53(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52), - const char* docstring = 0, ValidMethod valid = &yes_arity<53>) { - AddMethod(name_, new CppMethod53( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<53>) { - AddMethod(name_, new const_CppMethod53( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53), - const char* docstring = 0, ValidMethod valid = &yes_arity<54>) { - AddMethod( name_, new CppMethod54(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<54>) { - AddMethod(name_, new const_CppMethod54(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53), - const char* docstring = 0, ValidMethod valid = &yes_arity<54>) { - AddMethod(name_, new CppMethod54( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<54>) { - AddMethod(name_, new const_CppMethod54( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54), - const char* docstring = 0, ValidMethod valid = &yes_arity<55>) { - AddMethod( name_, new CppMethod55(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<55>) { - AddMethod(name_, new const_CppMethod55(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54), - const char* docstring = 0, ValidMethod valid = &yes_arity<55>) { - AddMethod(name_, new CppMethod55( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<55>) { - AddMethod(name_, new const_CppMethod55( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55), - const char* docstring = 0, ValidMethod valid = &yes_arity<56>) { - AddMethod( name_, new CppMethod56(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<56>) { - AddMethod(name_, new const_CppMethod56(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55), - const char* docstring = 0, ValidMethod valid = &yes_arity<56>) { - AddMethod(name_, new CppMethod56( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<56>) { - AddMethod(name_, new const_CppMethod56( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56), - const char* docstring = 0, ValidMethod valid = &yes_arity<57>) { - AddMethod( name_, new CppMethod57(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<57>) { - AddMethod(name_, new const_CppMethod57(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56), - const char* docstring = 0, ValidMethod valid = &yes_arity<57>) { - AddMethod(name_, new CppMethod57( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<57>) { - AddMethod(name_, new const_CppMethod57( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57), - const char* docstring = 0, ValidMethod valid = &yes_arity<58>) { - AddMethod( name_, new CppMethod58(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<58>) { - AddMethod(name_, new const_CppMethod58(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57), - const char* docstring = 0, ValidMethod valid = &yes_arity<58>) { - AddMethod(name_, new CppMethod58( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<58>) { - AddMethod(name_, new const_CppMethod58( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58), - const char* docstring = 0, ValidMethod valid = &yes_arity<59>) { - AddMethod( name_, new CppMethod59(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<59>) { - AddMethod(name_, new const_CppMethod59(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58), - const char* docstring = 0, ValidMethod valid = &yes_arity<59>) { - AddMethod(name_, new CppMethod59( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<59>) { - AddMethod(name_, new const_CppMethod59( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59), - const char* docstring = 0, ValidMethod valid = &yes_arity<60>) { - AddMethod( name_, new CppMethod60(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<60>) { - AddMethod(name_, new const_CppMethod60(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59), - const char* docstring = 0, ValidMethod valid = &yes_arity<60>) { - AddMethod(name_, new CppMethod60( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<60>) { - AddMethod(name_, new const_CppMethod60( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60), - const char* docstring = 0, ValidMethod valid = &yes_arity<61>) { - AddMethod( name_, new CppMethod61(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<61>) { - AddMethod(name_, new const_CppMethod61(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60), - const char* docstring = 0, ValidMethod valid = &yes_arity<61>) { - AddMethod(name_, new CppMethod61( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<61>) { - AddMethod(name_, new const_CppMethod61( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61), - const char* docstring = 0, ValidMethod valid = &yes_arity<62>) { - AddMethod( name_, new CppMethod62(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<62>) { - AddMethod(name_, new const_CppMethod62(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61), - const char* docstring = 0, ValidMethod valid = &yes_arity<62>) { - AddMethod(name_, new CppMethod62( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<62>) { - AddMethod(name_, new const_CppMethod62( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62), - const char* docstring = 0, ValidMethod valid = &yes_arity<63>) { - AddMethod( name_, new CppMethod63(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<63>) { - AddMethod(name_, new const_CppMethod63(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62), - const char* docstring = 0, ValidMethod valid = &yes_arity<63>) { - AddMethod(name_, new CppMethod63( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<63>) { - AddMethod(name_, new const_CppMethod63( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63), - const char* docstring = 0, ValidMethod valid = &yes_arity<64>) { - AddMethod( name_, new CppMethod64(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<64>) { - AddMethod(name_, new const_CppMethod64(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63), - const char* docstring = 0, ValidMethod valid = &yes_arity<64>) { - AddMethod(name_, new CppMethod64( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<64>) { - AddMethod(name_, new const_CppMethod64( fun ), valid, docstring); - return *this; -} - - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64), - const char* docstring = 0, ValidMethod valid = &yes_arity<65>) { - AddMethod( name_, new CppMethod65(fun), valid, docstring); - return *this; -} - -template -self& method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<65>) { - AddMethod(name_, new const_CppMethod65(fun), valid, docstring); - return *this ; -} - -template -self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64), - const char* docstring = 0, ValidMethod valid = &yes_arity<65>) { - AddMethod(name_, new CppMethod65( fun ), valid, docstring); - return *this; -} - -template -self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(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, U17 u17, U18 u18, U19 u19, U20 u20, U21 u21, U22 u22, U23 u23, U24 u24, U25 u25, U26 u26, U27 u27, U28 u28, U29 u29, U30 u30, U31 u31, U32 u32, U33 u33, U34 u34, U35 u35, U36 u36, U37 u37, U38 u38, U39 u39, U40 u40, U41 u41, U42 u42, U43 u43, U44 u44, U45 u45, U46 u46, U47 u47, U48 u48, U49 u49, U50 u50, U51 u51, U52 u52, U53 u53, U54 u54, U55 u55, U56 u56, U57 u57, U58 u58, U59 u59, U60 u60, U61 u61, U62 u62, U63 u63, U64 u64) const, - const char* docstring = 0, ValidMethod valid = &yes_arity<65>) { - AddMethod(name_, new const_CppMethod65( fun ), valid, docstring); - return *this; -} - -#endif - diff --git a/inst/include/Rcpp/module/class.h b/inst/include/Rcpp/module/class.h index d617f164e..7ada6b65e 100644 --- a/inst/include/Rcpp/module/class.h +++ b/inst/include/Rcpp/module/class.h @@ -1,7 +1,7 @@ // class.h: Rcpp R/C++ interface class library -- Rcpp modules // -// Copyright (C) 2012 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -110,21 +110,16 @@ return constructor( docstring, valid ) ; } -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - self& constructor( const char* docstring = 0, ValidConstructor valid = &yes_arity ){ - AddConstructor( new Constructor , valid, docstring ) ; - return *this ; - } - template - self& factory( Class* (*fun)(T...), const char* docstring = 0, ValidConstructor valid = &yes_arity ){ - AddFactory( new Factory(fun) , valid, docstring ) ; - return *this ; - } -#else - #include - #include -#endif + template + self& constructor( const char* docstring = 0, ValidConstructor valid = &yes_arity ){ + AddConstructor( new Constructor , valid, docstring ) ; + return *this ; + } + template + self& factory( Class* (*fun)(T...), const char* docstring = 0, ValidConstructor valid = &yes_arity ){ + AddFactory( new Factory(fun) , valid, docstring ) ; + return *this ; + } public: @@ -265,47 +260,42 @@ return *this ; } -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template - self& method(const char* name_, RESULT_TYPE (Class::*fun)(T...), - const char* docstring = 0, ValidMethod valid = &yes_arity) { - AddMethod( name_, new CppMethodN(fun), valid, docstring); - return *this; - } - template - self& method(const char* name_, RESULT_TYPE (Class::*fun)(T...) const, - const char* docstring = 0, ValidMethod valid = &yes_arity) { - AddMethod( name_, new const_CppMethodN(fun), valid, docstring); - return *this; - } - template - self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(T...), - const char* docstring = 0, ValidMethod valid = &yes_arity) { - AddMethod( name_, new CppMethodN(fun), valid, docstring); - return *this; - } - template - self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(T...) const, - const char* docstring = 0, ValidMethod valid = &yes_arity) { - AddMethod( name_, new const_CppMethodN(fun), valid, docstring); - return *this; - } - template - self& method(const char* name_, RESULT_TYPE (*fun)(Class*, T...), - const char* docstring = 0, ValidMethod valid = &yes_arity) { - AddMethod( name_, new Pointer_CppMethodN(fun), valid, docstring); - return *this; - } - template - self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, T...), - const char* docstring = 0, ValidMethod valid = &yes_arity) { - AddMethod( name_, new Const_Pointer_CppMethodN(fun), valid, docstring); - return *this; - } -#else - #include - #include -#endif + template + self& method(const char* name_, RESULT_TYPE (Class::*fun)(T...), + const char* docstring = 0, ValidMethod valid = &yes_arity) { + AddMethod( name_, new CppMethodN(fun), valid, docstring); + return *this; + } + template + self& method(const char* name_, RESULT_TYPE (Class::*fun)(T...) const, + const char* docstring = 0, ValidMethod valid = &yes_arity) { + AddMethod( name_, new const_CppMethodN(fun), valid, docstring); + return *this; + } + template + self& nonconst_method(const char* name_, RESULT_TYPE (Class::*fun)(T...), + const char* docstring = 0, ValidMethod valid = &yes_arity) { + AddMethod( name_, new CppMethodN(fun), valid, docstring); + return *this; + } + template + self& const_method(const char* name_, RESULT_TYPE (Class::*fun)(T...) const, + const char* docstring = 0, ValidMethod valid = &yes_arity) { + AddMethod( name_, new const_CppMethodN(fun), valid, docstring); + return *this; + } + template + self& method(const char* name_, RESULT_TYPE (*fun)(Class*, T...), + const char* docstring = 0, ValidMethod valid = &yes_arity) { + AddMethod( name_, new Pointer_CppMethodN(fun), valid, docstring); + return *this; + } + template + self& const_method(const char* name_, RESULT_TYPE (*fun)(const Class*, T...), + const char* docstring = 0, ValidMethod valid = &yes_arity) { + AddMethod( name_, new Const_Pointer_CppMethodN(fun), valid, docstring); + return *this; + } bool has_method( const std::string& m){ return vec_methods.find(m) != vec_methods.end() ; diff --git a/inst/include/Rcpp/platform/compiler.h b/inst/include/Rcpp/platform/compiler.h index 3a000038c..3f75161b2 100644 --- a/inst/include/Rcpp/platform/compiler.h +++ b/inst/include/Rcpp/platform/compiler.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// // compiler.h: Rcpp R/C++ interface class library -- check compiler // -// Copyright (C) 2012 - 2013 Dirk Eddelbuettel, Romain Francois, and Kevin Ushey +// Copyright (C) 2012 - 2025 Dirk Eddelbuettel, Romain Francois, and Kevin Ushey +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois, Kevin Ushey and Iñaki Ucar // // This file is part of Rcpp. // @@ -24,173 +23,26 @@ // NB: A vast list valid identifiers is at these wiki pages: // http://sourceforge.net/p/predef/wiki/Home/ - -#undef GOOD_COMPILER_FOR_RCPP -#ifdef __GNUC__ -#define GOOD_COMPILER_FOR_RCPP -#endif -#ifdef __SUNPRO_CC -#define GOOD_COMPILER_FOR_RCPP -#endif -#ifdef __clang__ -#define GOOD_COMPILER_FOR_RCPP -#endif -#ifdef __INTEL_COMPILER -#define GOOD_COMPILER_FOR_RCPP -#endif - -#ifndef GOOD_COMPILER_FOR_RCPP -# error "This compiler is not supported" -#endif - -#ifdef __GNUC__ - #define GCC_VERSION (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) - // g++ 4.5 does not seem to like some of the fast indexing - #if GCC_VERSION >= 40500 - #define IS_GCC_450_OR_LATER - #endif - // g++ 4.6 switches from exception_defines.h to bits/exception_defines.h - #if GCC_VERSION < 40600 - #define IS_EARLIER_THAN_GCC_460 - #endif - #if GCC_VERSION >= 40600 - #define IS_GCC_460_OR_LATER - #endif -#endif - -// Check for the presence of C++0x (or later) support -#if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103L) - #define RCPP_USING_CXX0X_OR_LATER +#if !defined(__GNUC__) && !defined(__SUNPRO_CC) && !defined(__clang__) && !defined(__INTEL_COMPILER) +#error "This compiler is not supported" #endif -// Check C++0x/11 features -#if defined(__INTEL_COMPILER) - #if __cplusplus >= 201103L - #define RCPP_USING_CXX11 - #if __INTEL_COMPILER >= 1210 - // #define HAS_VARIADIC_TEMPLATES - #endif - #if __INTEL_COMPILER >= 1100 - #define HAS_STATIC_ASSERT - #endif - #endif -#elif defined(__clang__) - #if __cplusplus >= 201103L - #define RCPP_USING_CXX11 - #if __has_feature(cxx_variadic_templates) - // #define HAS_VARIADIC_TEMPLATES - #endif - #if __has_feature(cxx_static_assert) - #define HAS_STATIC_ASSERT - #endif - #endif -#elif defined(__GNUC__) - #ifdef __GXX_EXPERIMENTAL_CXX0X__ - #if GCC_VERSION >= 40300 - // #define HAS_VARIADIC_TEMPLATES - #define HAS_STATIC_ASSERT - #endif - #endif - #if GCC_VERSION >= 40800 && __cplusplus >= 201103L - #define RCPP_USING_CXX11 - #endif +// Simpler test and minimal standard: C++11 or else we die +#if __cplusplus < 201103L +#error "The C++ compilation standard is too old: use C++11 or newer." #endif -// Check C++0x headers +// C++11 features -- that used to be carefully tested for or worked around via CXX0X / TR1 +// These defines are all planned to get removed just how a number have already been removed. One at a time... #include -#if defined(__INTEL_COMPILER) || (defined(__GNUC__) && !defined(__clang__)) - #if defined(__GLIBCXX__) && defined(__GXX_EXPERIMENTAL_CXX0X__) - #if GCC_VERSION >= 40400 - #define HAS_CXX0X_UNORDERED_MAP - #define HAS_CXX0X_UNORDERED_SET - #define HAS_CXX0X_INITIALIZER_LIST - #endif - #endif -#elif defined(__clang__) - #if __cplusplus >= 201103L - #if __has_include() - #define HAS_CXX0X_UNORDERED_MAP - #endif - #if __has_include() - #define HAS_CXX0X_UNORDERED_SET - #endif - #if __has_include() - #define HAS_CXX0X_INITIALIZER_LIST - #endif - #endif -#endif - -// Check TR1 Headers -#if defined(__INTEL_COMPILER) || (defined(__GNUC__) && !defined(__clang__)) - #if defined(__GLIBCXX__) - #if GCC_VERSION >= 40400 || ( GCC_VERSION >= 40201 && defined(__APPLE__) ) - #define HAS_TR1_UNORDERED_MAP - #define HAS_TR1_UNORDERED_SET - #endif - #endif -#elif defined(__clang__) - #if __cplusplus >= 201103L - #if __has_include() - #define HAS_TR1_UNORDERED_MAP - #endif - #if __has_include() - #define HAS_TR1_UNORDERED_SET - #endif - #endif -#endif - -#if defined(HAS_TR1_UNORDERED_MAP) && defined(HAS_TR1_UNORDERED_SET) -#define HAS_TR1 -#endif - -// Conditionally include headers -#ifdef HAS_CXX0X_INITIALIZER_LIST #include -#endif +#include +#define RCPP_UNORDERED_MAP std::unordered_map // TODO deprecate +#include +#define RCPP_UNORDERED_SET std::unordered_set // TODO deprecate -#ifdef RCPP_USING_CXX11 - #if defined(HAS_CXX0X_UNORDERED_MAP) - #include - #define RCPP_USING_UNORDERED_MAP - #define RCPP_UNORDERED_MAP std::unordered_map - #else - #include - #define RCPP_USING_MAP - #define RCPP_UNORDERED_MAP std::map - #endif - #if defined(HAS_CXX0X_UNORDERED_SET) - #include - #define RCPP_USING_UNORDERED_SET - #define RCPP_UNORDERED_SET std::unordered_set - #else - #include - #define RCPP_USING_SET - #define RCPP_UNORDERED_SET std::set - #endif -#else - #if defined(HAS_TR1_UNORDERED_MAP) - #include - #define RCPP_USING_TR1_UNORDERED_MAP - #define RCPP_UNORDERED_MAP std::tr1::unordered_map - #else - #include - #define RCPP_USING_MAP - #define RCPP_UNORDERED_MAP std::map - #endif - #if defined(HAS_TR1_UNORDERED_SET) - #include - #define RCPP_USING_TR1_UNORDERED_SET - #define RCPP_UNORDERED_SET std::tr1::unordered_set - #else - #include - #define RCPP_USING_SET - #define RCPP_UNORDERED_SET std::set - #endif -#endif - -#ifdef __GNUC__ +#if defined(__GNUC__) #define RCPP_HAS_DEMANGLING #endif - #endif diff --git a/inst/include/Rcpp/proxy/AttributeProxy.h b/inst/include/Rcpp/proxy/AttributeProxy.h index a84043d72..f3e31466f 100644 --- a/inst/include/Rcpp/proxy/AttributeProxy.h +++ b/inst/include/Rcpp/proxy/AttributeProxy.h @@ -78,24 +78,29 @@ class AttributeProxyPolicy { } std::vector attributeNames() const { - std::vector v ; + std::vector v; +#if R_VERSION >= R_Version(4, 6, 0) + SEXP attrs = R_getAttribNames( static_cast(*this)); + R_xlen_t n = XLENGTH(attrs); + for (R_xlen_t i = 0; i < n; i++) { + v.push_back(std::string(CHAR(STRING_ELT(attrs, i)))); + } +#else SEXP attrs = ATTRIB( static_cast(*this).get__()); while( attrs != R_NilValue ){ v.push_back( std::string(CHAR(PRINTNAME(TAG(attrs)))) ) ; attrs = CDR( attrs ) ; } - return v ; +#endif + return v; } - bool hasAttribute( const std::string& attr) const { - SEXP attrs = ATTRIB(static_cast(*this).get__()); - while( attrs != R_NilValue ){ - if( attr == CHAR(PRINTNAME(TAG(attrs))) ){ - return true ; - } - attrs = CDR( attrs ) ; - } - return false; /* give up */ + bool hasAttribute(const std::string& attr) const { +#if R_VERSION >= R_Version(4, 6, 0) + return R_hasAttrib(static_cast(*this).get__(), Rf_install(attr.c_str())); +#else + return static_cast(*this).attr(attr) != R_NilValue; +#endif } diff --git a/inst/include/Rcpp/proxy/NamesProxy.h b/inst/include/Rcpp/proxy/NamesProxy.h index 694dda9b3..2717b2a78 100644 --- a/inst/include/Rcpp/proxy/NamesProxy.h +++ b/inst/include/Rcpp/proxy/NamesProxy.h @@ -1,4 +1,5 @@ -// Copyright (C) 2013 Romain Francois +// Copyright (C) 2013 - 2025 Romain François +// Copyright (C) 2026 Romain François, Iñaki Ucar and Dirk Eddelbuettel // // This file is part of Rcpp. // @@ -43,23 +44,13 @@ class NamesProxyPolicy{ CLASS& parent; SEXP get() const { - return RCPP_GET_NAMES(parent.get__()) ; + return RCPP_GET_NAMES(parent) ; } void set(SEXP x) { - Shield safe_x(x); - - /* check if we can use a fast version */ - if( TYPEOF(x) == STRSXP && parent.size() == Rf_length(x) ){ - Rf_namesgets(parent, x); - } else { - /* use the slower and more flexible version (callback to R) */ - SEXP namesSym = Rf_install( "names<-" ); - Shield call(Rf_lang3(namesSym, parent, x)); - Shield new_vec(Rcpp_fast_eval(call, R_GlobalEnv)); - parent.set__(new_vec); - } - + if (!Rf_isNull(x)) + Rf_namesgets(parent, x); + else Rf_setAttrib(parent, R_NamesSymbol, x); } } ; @@ -74,7 +65,7 @@ class NamesProxyPolicy{ const CLASS& parent; SEXP get() const { - return RCPP_GET_NAMES(parent.get__()) ; + return RCPP_GET_NAMES(parent) ; } } ; diff --git a/inst/include/Rcpp/proxy/SlotProxy.h b/inst/include/Rcpp/proxy/SlotProxy.h index 718a83054..c6d3f4f76 100644 --- a/inst/include/Rcpp/proxy/SlotProxy.h +++ b/inst/include/Rcpp/proxy/SlotProxy.h @@ -28,7 +28,7 @@ class SlotProxyPolicy { public: SlotProxy( CLASS& v, const std::string& name) : parent(v), slot_name(Rf_install(name.c_str())) { if( !R_has_slot( v, slot_name) ){ - throw no_such_slot(name); + throw no_such_slot(name); // #nocov } } diff --git a/inst/include/Rcpp/r/check_r_headers.h b/inst/include/Rcpp/r/check_r_headers.h new file mode 100644 index 000000000..9bddb5619 --- /dev/null +++ b/inst/include/Rcpp/r/check_r_headers.h @@ -0,0 +1,44 @@ +// check_r_headers.h: Rcpp R/C++ interface class library -- R header check +// +// Copyright (C) 2025 - current Dirk Eddelbuettel +// +// 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 . + +#ifndef RCPP__CHECK__R__HEADERS__H +#define RCPP__CHECK__R__HEADERS__H + +// Allow an escape hatch +#if !defined(RCPP_NO_R_HEADERS_CHECK) + + #if defined(R_R_H) && defined(USING_R) + #pragma message "R.h has been included before any Rcpp headers. This can lead to hard-to-debug errors, and is not necessary. See https://github.com/RcppCore/Rcpp/issues/1410" + #endif + + #if defined(RINTERFACE_H_) + #pragma message "Rinterface.h has been included before any Rcpp headers. This can lead to hard-to-debug errors, and is not necessary. See https://github.com/RcppCore/Rcpp/issues/1410" + #endif + + #if defined(R_INTERNALS_H_) + #pragma message "Rinternals.h has been included before any Rcpp headers. This can lead to hard-to-debug errors, and is not necessary. See https://github.com/RcppCore/Rcpp/issues/1410" + #endif + + #if defined(R_DEFINES_H_) + #pragma message "Rdefines.h has been included before any Rcpp headers. This can lead to hard-to-debug errors, and is not necessary. See https://github.com/RcppCore/Rcpp/issues/1410" + #endif + +#endif // escape hatch '!defined(RCPP_NO_R_HEADERS_CHECK)' + +#endif // header guard diff --git a/inst/include/Rcpp/r/compat.h b/inst/include/Rcpp/r/compat.h index 218f3d7bc..720471b89 100644 --- a/inst/include/Rcpp/r/compat.h +++ b/inst/include/Rcpp/r/compat.h @@ -24,13 +24,13 @@ #include -#if R_VERSION >= R_Version(4, 4, 2) +#if R_VERSION >= R_Version(4, 5, 0) # define RCPP_STRING_PTR STRING_PTR_RO #else # define RCPP_STRING_PTR STRING_PTR #endif -#if R_VERSION >= R_Version(4, 4, 2) +#if R_VERSION >= R_Version(4, 5, 0) # define RCPP_VECTOR_PTR VECTOR_PTR_RO #else # define RCPP_VECTOR_PTR VECTOR_PTR diff --git a/inst/include/Rcpp/r/headers.h b/inst/include/Rcpp/r/headers.h index c93636c40..7bf972a3c 100644 --- a/inst/include/Rcpp/r/headers.h +++ b/inst/include/Rcpp/r/headers.h @@ -2,6 +2,7 @@ // // Copyright (C) 2008 - 2009 Dirk Eddelbuettel // Copyright (C) 2009 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 - Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -72,6 +73,7 @@ #include #include #include +#include #include /* Ensure NORET defined (normally provided by R headers with R >= 3.2.0) */ @@ -99,8 +101,4 @@ # pragma pop_macro("makedev") #endif -#if (!defined(RCPP_NO_UNWIND_PROTECT) && defined(R_VERSION) && R_VERSION >= R_Version(3, 5, 0)) -# define RCPP_USING_UNWIND_PROTECT -#endif - #endif /* RCPP__R__HEADERS__H */ diff --git a/inst/include/Rcpp/r_cast.h b/inst/include/Rcpp/r_cast.h index 327eaa96d..7f26d8966 100644 --- a/inst/include/Rcpp/r_cast.h +++ b/inst/include/Rcpp/r_cast.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // rcast.h: Rcpp R/C++ interface class library -- cast from one SEXP type to another // -// Copyright (C) 2010 - 2017 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -143,14 +142,9 @@ namespace Rcpp { } template<> inline SEXP r_true_cast(SEXP x) { - switch( TYPEOF(x) ){ - case LANGSXP: - { - Shield y( Rf_duplicate( x )); - SET_TYPEOF(y,LISTSXP); - return y; - } - default: + if (TYPEOF(x) == LANGSXP) { + return Rf_cons(CAR(x), CDR(x)); + } else { return convert_using_rfunction(x, "as.pairlist" ); } } @@ -161,7 +155,7 @@ namespace Rcpp { } // namespace internal - template SEXP r_cast(SEXP x) { + template SEXP r_cast(SEXP x) { // #nocov start if (TYPEOF(x) == TARGET) { return x; } else { @@ -173,7 +167,7 @@ namespace Rcpp { ); return result; #else - return internal::r_true_cast(x); // #nocov + return internal::r_true_cast(x); // #nocov end #endif } } diff --git a/inst/include/Rcpp/sugar/functions/cumprod.h b/inst/include/Rcpp/sugar/functions/cumprod.h index 59cf8d4bd..0ad8936fd 100644 --- a/inst/include/Rcpp/sugar/functions/cumprod.h +++ b/inst/include/Rcpp/sugar/functions/cumprod.h @@ -2,7 +2,8 @@ // // cumsum.h: Rcpp R/C++ interface class library -- cumsum // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -33,23 +34,23 @@ class Cumprod : public Lazy< Rcpp::Vector, Cumprod > { typedef Rcpp::Vector VECTOR; Cumprod(const VEC_TYPE& object_) : object(object_) {} - + VECTOR get() const { R_xlen_t n = object.size(); VECTOR result(n, Rcpp::traits::get_na()); STORAGE current = object[0]; - + if (Rcpp::traits::is_na(current)) return result; result[0] = current; for (R_xlen_t i = 1; i < n; i++) { current = object[i]; if (Rcpp::traits::is_na(current)) return result; - result[i] = result[i-1] * current; + result[i] = RCPP_SAFE_MUL(result[i-1], current); } return result ; } private: - const VEC_TYPE& object; + const VEC_TYPE& object; }; } // sugar @@ -72,5 +73,5 @@ inline sugar::Cumprod cumprod(const VectorBase& } // Rcpp -#endif // Rcpp__sugar__cumprod_h +#endif // Rcpp__sugar__cumprod_h diff --git a/inst/include/Rcpp/sugar/functions/cumsum.h b/inst/include/Rcpp/sugar/functions/cumsum.h index e42e5bc35..cb8e53886 100644 --- a/inst/include/Rcpp/sugar/functions/cumsum.h +++ b/inst/include/Rcpp/sugar/functions/cumsum.h @@ -2,7 +2,8 @@ // // cumsum.h: Rcpp R/C++ interface class library -- cumsum // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -45,7 +46,7 @@ class Cumsum : public Lazy< Rcpp::Vector , Cumsum > { current = object[i] ; if( Rcpp::traits::is_na(current) ) return result ; - result[i] = result[i-1] + current ; + result[i] = RCPP_SAFE_ADD(result[i-1], current); } return result ; } diff --git a/inst/include/Rcpp/sugar/functions/diff.h b/inst/include/Rcpp/sugar/functions/diff.h index 5d9910c72..b6c43f3fd 100644 --- a/inst/include/Rcpp/sugar/functions/diff.h +++ b/inst/include/Rcpp/sugar/functions/diff.h @@ -2,7 +2,8 @@ // // diff.h: Rcpp R/C++ interface class library -- diff // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -51,7 +52,7 @@ class Diff : public Rcpp::VectorBase< RTYPE, LHS_NA , Diff > set_previous(i+1, y ) ; return traits::get_na() ; // NA } - STORAGE res = y - previous ; + STORAGE res = RCPP_SAFE_SUB(y, previous); set_previous( i+1, y) ; return res ; } @@ -81,7 +82,7 @@ class Diff : public Rcpp::VectorBase< REALSXP, LHS_NA, D inline double operator[]( R_xlen_t i ) const { double y = lhs[i+1] ; if( previous_index != i ) previous = lhs[i] ; - double res = y - previous ; + double res = RCPP_SAFE_SUB(y, previous); previous = y ; previous_index = i+1 ; return res ; @@ -105,10 +106,10 @@ class Diff : public Rcpp::VectorBase< RTYPE, false , Diff { public: typedef Rcpp::VectorBase VEC ; - typedef typename ::Rcpp::traits::result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; Lapply( const VEC& vec_, Function fun_ ) : vec(vec_), fun(fun_){} diff --git a/inst/include/Rcpp/sugar/functions/mapply/mapply_2.h b/inst/include/Rcpp/sugar/functions/mapply/mapply_2.h index 9173fddc1..8185f6220 100644 --- a/inst/include/Rcpp/sugar/functions/mapply/mapply_2.h +++ b/inst/include/Rcpp/sugar/functions/mapply/mapply_2.h @@ -2,7 +2,8 @@ // // mapply_2.h: Rcpp R/C++ interface class library -- mapply_2 // -// Copyright (C) 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -32,13 +33,13 @@ template class Mapply_2 : public VectorBase< Rcpp::traits::r_sexptype_traits< - typename ::Rcpp::traits::result_of::type + typename ::Rcpp::traits::result_of::type >::rtype , true , Mapply_2 > { public: - typedef typename ::Rcpp::traits::result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; Mapply_2( const T_1& vec_1_, const T_2& vec_2_, Function fun_ ) : vec_1(vec_1_), vec_2(vec_2_), fun(fun_){} @@ -62,14 +63,14 @@ template ::type + typename ::Rcpp::traits::result_of::type >::rtype , true , Mapply_2_Vector_Primitive > { public: - typedef typename ::Rcpp::traits::result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; Mapply_2_Vector_Primitive( const T_1& vec_1_, PRIM_2 prim_2_, Function fun_ ) : vec_1(vec_1_), prim_2(prim_2_), fun(fun_){} @@ -93,14 +94,14 @@ template ::type + typename ::Rcpp::traits::result_of::type >::rtype , true , Mapply_2_Primitive_Vector > { public: - typedef typename ::Rcpp::traits::result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; Mapply_2_Primitive_Vector( PRIM_1 prim_1_, const T_2& vec_2_, Function fun_ ) : prim_1(prim_1_), vec_2(vec_2_), fun(fun_){} diff --git a/inst/include/Rcpp/sugar/functions/mapply/mapply_3.h b/inst/include/Rcpp/sugar/functions/mapply/mapply_3.h index 6f6e04c20..e009b9142 100644 --- a/inst/include/Rcpp/sugar/functions/mapply/mapply_3.h +++ b/inst/include/Rcpp/sugar/functions/mapply/mapply_3.h @@ -2,7 +2,8 @@ // // mapply_3.h: Rcpp R/C++ interface class library -- mapply_3 // -// Copyright (C) 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -33,13 +34,13 @@ template < > class Mapply_3 : public VectorBase< Rcpp::traits::r_sexptype_traits< - typename ::Rcpp::traits::result_of::type + typename ::Rcpp::traits::result_of::type >::rtype , true , Mapply_3 > { public: - typedef typename ::Rcpp::traits::result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; typedef Rcpp::VectorBase VEC_1 ; typedef Rcpp::VectorBase VEC_2 ; diff --git a/inst/include/Rcpp/sugar/functions/max.h b/inst/include/Rcpp/sugar/functions/max.h index de56d24f5..7f85b1457 100644 --- a/inst/include/Rcpp/sugar/functions/max.h +++ b/inst/include/Rcpp/sugar/functions/max.h @@ -1,7 +1,8 @@ // max.h: Rcpp R/C++ interface class library -- max // -// Copyright (C) 2012 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -33,7 +34,11 @@ namespace sugar{ operator STORAGE() const { R_xlen_t n = obj.size(); - if (n == 0) return(static_cast(R_NegInf)); + if (n == 0) { + if (RTYPE != REALSXP) + Rcpp::stop("missing argument to max"); + return(static_cast(R_NegInf)); + } STORAGE max, current ; max = obj[0] ; @@ -60,7 +65,11 @@ namespace sugar{ operator STORAGE() const { R_xlen_t n = obj.size(); - if (n == 0) return(static_cast(R_NegInf)); + if (n == 0) { + if (RTYPE != REALSXP) + Rcpp::stop("missing argument to max"); + return(static_cast(R_NegInf)); + } STORAGE max, current ; max = obj[0] ; diff --git a/inst/include/Rcpp/sugar/functions/min.h b/inst/include/Rcpp/sugar/functions/min.h index 7b77407a3..0e8b9410e 100644 --- a/inst/include/Rcpp/sugar/functions/min.h +++ b/inst/include/Rcpp/sugar/functions/min.h @@ -1,7 +1,8 @@ // Min.h: Rcpp R/C++ interface class library -- min // -// Copyright (C) 2012 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -33,7 +34,11 @@ namespace sugar{ operator STORAGE() const { R_xlen_t n = obj.size(); - if (n == 0) return(static_cast(R_PosInf)); + if (n == 0) { + if (RTYPE != REALSXP) + Rcpp::stop("missing argument to min"); + return(static_cast(R_PosInf)); + } STORAGE min, current ; min = obj[0] ; @@ -60,7 +65,11 @@ namespace sugar{ operator STORAGE() const { R_xlen_t n = obj.size(); - if (n == 0) return(static_cast(R_PosInf)); + if (n == 0) { + if (RTYPE != REALSXP) + Rcpp::stop("missing argument to min"); + return(static_cast(R_PosInf)); + } STORAGE min, current ; min = obj[0] ; diff --git a/inst/include/Rcpp/sugar/functions/rowSums.h b/inst/include/Rcpp/sugar/functions/rowSums.h index 99adbd8d2..ec9b26acb 100644 --- a/inst/include/Rcpp/sugar/functions/rowSums.h +++ b/inst/include/Rcpp/sugar/functions/rowSums.h @@ -1,8 +1,9 @@ // -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- // -// rowSums.h: Rcpp R/C++ interface class library -- rowSums, colSums, rowMeans, colMeans +// rowSums.h: Rcpp R/C++ interface class library -- rowSums, colSums, rowMeans, colMeans // -// Copyright (C) 2016 Nathan Russell +// Copyright (C) 2016 - 2025 Nathan Russell +// Copyright (C) 2026 Nathan Russell and Iñaki Ucar // // This file is part of Rcpp. // @@ -27,33 +28,12 @@ namespace sugar { namespace detail { -inline bool check_na(double x) { - return ISNAN(x); -} - -inline bool check_na(int x) { - return x == NA_INTEGER; -} - -inline bool check_na(Rboolean x) { - return x == NA_LOGICAL; -} - -inline bool check_na(SEXP x) { - return x == NA_STRING; -} - -inline bool check_na(Rcomplex x) { - return ISNAN(x.r) || ISNAN(x.i); -} - - inline void incr(double* lhs, double rhs) { *lhs += rhs; } inline void incr(int* lhs, int rhs) { - *lhs += rhs; + *lhs = RCPP_SAFE_ADD(*lhs, rhs); } inline void incr(Rcomplex* lhs, const Rcomplex& rhs) { @@ -159,12 +139,12 @@ class RowSumsImpl : // INTSXP output // // int + NA_LOGICAL (NA_INTEGER) != NA_INTEGER, as is the -// case with NA_REAL, so we specialize for these two SEXPTYPES -// and do explicit accounting of NAs. -// +// case with NA_REAL, so we specialize for these two SEXPTYPES +// and do explicit accounting of NAs. +// // The two specializations, while necessary, are redundant, hence -// the macro. The same applies to the 'na.rm = TRUE' variant, and -// likewise for colSums, rowMeans, and colMeans. +// the macro. The same applies to the 'na.rm = TRUE' variant, and +// likewise for colSums, rowMeans, and colMeans. // #define ROW_SUMS_IMPL_KEEPNA(__RTYPE__) \ \ @@ -178,10 +158,6 @@ private: typedef typename return_traits::type return_vector; \ typedef typename traits::storage_type::type stored_type; \ \ - struct bit { \ - unsigned char x : 1; \ - }; \ - \ public: \ RowSumsImpl(const MatrixBase<__RTYPE__, NA, T>& ref_) \ : ref(ref_) \ @@ -191,29 +167,22 @@ public: R_xlen_t i, j, nr = ref.nrow(), nc = ref.ncol(); \ return_vector res(nr); \ \ - std::vector na_flags(nr); \ - \ for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ - if (detail::check_na(ref(i, j))) { \ - na_flags[i].x |= 0x1; \ - } \ - detail::incr(&res[i], ref(i, j)); \ - } \ - } \ - \ - for (i = 0; i < nr; i++) { \ - if (na_flags[i].x) { \ - res[i] = NA_INTEGER; \ + if (traits::is_na<__RTYPE__>(res[i])) \ + continue; \ + if (traits::is_na<__RTYPE__>(ref(i, j))) \ + res[i] = traits::get_na<__RTYPE__>(); \ + else detail::incr(&res[i], ref(i, j)); \ } \ } \ \ return res; \ } \ -}; +}; -ROW_SUMS_IMPL_KEEPNA(LGLSXP) -ROW_SUMS_IMPL_KEEPNA(INTSXP) +ROW_SUMS_IMPL_KEEPNA(LGLSXP) +ROW_SUMS_IMPL_KEEPNA(INTSXP) #undef ROW_SUMS_IMPL_KEEPNA @@ -246,7 +215,7 @@ class RowSumsImpl : for (j = 0; j < nc; j++) { for (i = 0; i < nr; i++) { current = ref(i, j); - if (!detail::check_na(current)) { + if (!traits::is_na(current)) { detail::incr(&res[i], current); } } @@ -287,7 +256,7 @@ public: for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ current = ref(i, j); \ - if (!detail::check_na(current)) { \ + if (!traits::is_na<__RTYPE__>(current)) { \ detail::incr(&res[i], current); \ } \ } \ @@ -295,10 +264,10 @@ public: \ return res; \ } \ -}; +}; -ROW_SUMS_IMPL_RMNA(LGLSXP) -ROW_SUMS_IMPL_RMNA(INTSXP) +ROW_SUMS_IMPL_RMNA(LGLSXP) +ROW_SUMS_IMPL_RMNA(INTSXP) #undef ROW_SUMS_IMPL_RMNA @@ -362,10 +331,6 @@ private: typedef typename return_traits::type return_vector; \ typedef typename traits::storage_type::type stored_type; \ \ - struct bit { \ - unsigned char x : 1; \ - }; \ - \ public: \ ColSumsImpl(const MatrixBase<__RTYPE__, NA, T>& ref_) \ : ref(ref_) \ @@ -375,20 +340,13 @@ public: R_xlen_t i, j, nr = ref.nrow(), nc = ref.ncol(); \ return_vector res(nc); \ \ - std::vector na_flags(nc); \ - \ for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ - if (detail::check_na(ref(i, j))) { \ - na_flags[j].x |= 0x1; \ - } \ - detail::incr(&res[j], ref(i, j)); \ - } \ - } \ - \ - for (j = 0; j < nc; j++) { \ - if (na_flags[j].x) { \ - res[j] = NA_INTEGER; \ + if (traits::is_na<__RTYPE__>(res[j])) \ + continue; \ + if (traits::is_na<__RTYPE__>(ref(i, j))) \ + res[j] = traits::get_na<__RTYPE__>(); \ + else detail::incr(&res[j], ref(i, j)); \ } \ } \ \ @@ -396,11 +354,11 @@ public: } \ }; -COL_SUMS_IMPL_KEEPNA(LGLSXP) -COL_SUMS_IMPL_KEEPNA(INTSXP) +COL_SUMS_IMPL_KEEPNA(LGLSXP) +COL_SUMS_IMPL_KEEPNA(INTSXP) #undef COL_SUMS_IMPL_KEEPNA - + // ColSums // na.rm = TRUE // default input @@ -430,7 +388,7 @@ class ColSumsImpl : for (j = 0; j < nc; j++) { for (i = 0; i < nr; i++) { current = ref(i, j); - if (!detail::check_na(current)) { + if (!traits::is_na(current)) { detail::incr(&res[j], current); } } @@ -471,7 +429,7 @@ public: for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ current = ref(i, j); \ - if (!detail::check_na(current)) { \ + if (!traits::is_na<__RTYPE__>(current)) { \ detail::incr(&res[j], current); \ } \ } \ @@ -481,8 +439,8 @@ public: } \ }; -COL_SUMS_IMPL_RMNA(LGLSXP) -COL_SUMS_IMPL_RMNA(INTSXP) +COL_SUMS_IMPL_RMNA(LGLSXP) +COL_SUMS_IMPL_RMNA(INTSXP) #undef COL_SUMS_IMPL_RMNA @@ -553,10 +511,6 @@ private: typedef typename return_traits::type return_vector; \ typedef typename traits::storage_type::type stored_type; \ \ - struct bit { \ - unsigned char x : 1; \ - }; \ - \ public: \ RowMeansImpl(const MatrixBase<__RTYPE__, NA, T>& ref_) \ : ref(ref_) \ @@ -566,34 +520,29 @@ public: R_xlen_t i, j, nr = ref.nrow(), nc = ref.ncol(); \ return_vector res(nr); \ \ - std::vector na_flags(nc); \ - \ for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ - if (detail::check_na(ref(i, j))) { \ - na_flags[i].x |= 0x1; \ - } \ - detail::incr(&res[i], ref(i, j)); \ + if (traits::is_na(res[i])) \ + continue; \ + if (traits::is_na<__RTYPE__>(ref(i, j))) \ + res[i] = traits::get_na(); \ + else detail::incr(&res[i], ref(i, j)); \ } \ } \ \ - for (i = 0; i < nr; i++) { \ - if (!na_flags[i].x) { \ + for (i = 0; i < nr; i++) \ + if (!traits::is_na(res[i])) \ detail::div(&res[i], nc); \ - } else { \ - res[i] = NA_REAL; \ - } \ - } \ \ return res; \ } \ }; -ROW_MEANS_IMPL_KEEPNA(LGLSXP) -ROW_MEANS_IMPL_KEEPNA(INTSXP) +ROW_MEANS_IMPL_KEEPNA(LGLSXP) +ROW_MEANS_IMPL_KEEPNA(INTSXP) #undef ROW_MEANS_IMPL_KEEPNA - + // RowMeans // na.rm = TRUE // default input @@ -625,7 +574,7 @@ class RowMeansImpl : for (j = 0; j < nc; j++) { for (i = 0; i < nr; i++) { current = ref(i, j); - if (!detail::check_na(current)) { + if (!traits::is_na(current)) { detail::incr(&res[i], ref(i, j)); ++n_ok[i]; } @@ -674,7 +623,7 @@ public: \ for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ - if (!detail::check_na(ref(i, j))) { \ + if (!traits::is_na<__RTYPE__>(ref(i, j))) { \ detail::incr(&res[i], ref(i, j)); \ ++n_ok[i]; \ } \ @@ -693,8 +642,8 @@ public: } \ }; -ROW_MEANS_IMPL_RMNA(LGLSXP) -ROW_MEANS_IMPL_RMNA(INTSXP) +ROW_MEANS_IMPL_RMNA(LGLSXP) +ROW_MEANS_IMPL_RMNA(INTSXP) #undef ROW_MEANS_IMPL_RMNA @@ -762,10 +711,6 @@ private: typedef typename return_traits::type return_vector; \ typedef typename traits::storage_type::type stored_type; \ \ - struct bit { \ - unsigned char x : 1; \ - }; \ - \ public: \ ColMeansImpl(const MatrixBase<__RTYPE__, NA, T>& ref_) \ : ref(ref_) \ @@ -775,31 +720,26 @@ public: R_xlen_t i, j, nr = ref.nrow(), nc = ref.ncol(); \ return_vector res(nc); \ \ - std::vector na_flags(nc); \ - \ for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ - if (detail::check_na(ref(i, j))) { \ - na_flags[j].x |= 0x1; \ - } \ - detail::incr(&res[j], ref(i, j)); \ + if (traits::is_na(res[j])) \ + continue; \ + if (traits::is_na<__RTYPE__>(ref(i, j))) \ + res[j] = traits::get_na(); \ + else detail::incr(&res[j], ref(i, j)); \ } \ } \ \ - for (j = 0; j < nc; j++) { \ - if (!na_flags[j].x) { \ + for (j = 0; j < nc; j++) \ + if (!traits::is_na(res[j])) \ detail::div(&res[j], nr); \ - } else { \ - res[j] = NA_REAL; \ - } \ - } \ \ return res; \ } \ }; -COL_MEANS_IMPL_KEEPNA(LGLSXP) -COL_MEANS_IMPL_KEEPNA(INTSXP) +COL_MEANS_IMPL_KEEPNA(LGLSXP) +COL_MEANS_IMPL_KEEPNA(INTSXP) #undef COL_MEANS_IMPL_KEEPNA @@ -834,7 +774,7 @@ class ColMeansImpl : for (j = 0; j < nc; j++) { for (i = 0; i < nr; i++) { current = ref(i, j); - if (!detail::check_na(current)) { + if (!traits::is_na(current)) { detail::incr(&res[j], ref(i, j)); ++n_ok[j]; } @@ -883,7 +823,7 @@ public: \ for (j = 0; j < nc; j++) { \ for (i = 0; i < nr; i++) { \ - if (!detail::check_na(ref(i, j))) { \ + if (!traits::is_na<__RTYPE__>(ref(i, j))) { \ detail::incr(&res[j], ref(i, j)); \ ++n_ok[j]; \ } \ @@ -902,11 +842,11 @@ public: } \ }; -COL_MEANS_IMPL_RMNA(LGLSXP) -COL_MEANS_IMPL_RMNA(INTSXP) +COL_MEANS_IMPL_RMNA(LGLSXP) +COL_MEANS_IMPL_RMNA(INTSXP) #undef COL_MEANS_IMPL_RMNA - + // ColMeans // Input with template parameter NA = false // ColMeansImpl<..., NA_RM = false> diff --git a/inst/include/Rcpp/sugar/functions/sapply.h b/inst/include/Rcpp/sugar/functions/sapply.h index 49ed29a3e..5b1311c5e 100644 --- a/inst/include/Rcpp/sugar/functions/sapply.h +++ b/inst/include/Rcpp/sugar/functions/sapply.h @@ -1,7 +1,8 @@ // sapply.h: Rcpp R/C++ interface class library -- sapply // -// Copyright (C) 2010 - 2023 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -21,42 +22,19 @@ #ifndef Rcpp__sugar__sapply_h #define Rcpp__sugar__sapply_h -#if defined(RCPP_USING_CXX0X_OR_LATER) - #include // ::std::result_of -#endif - namespace Rcpp{ namespace sugar{ -template -struct sapply_application_result_of -{ -#if defined(RCPP_USING_CXX0X_OR_LATER) - #if __cplusplus < 201703L - // deprecated by C++17, removed by C++2020, see https://en.cppreference.com/w/cpp/types/result_of - typedef typename ::std::result_of::type type; - #else - // since C++17, see https://en.cppreference.com/w/cpp/types/result_of - typedef typename ::std::invoke_result::type type; - #endif -#else - typedef typename ::Rcpp::traits::result_of::type type; -#endif -} ; - -// template -// using sapply_application_result_of_t = typename sapply_application_result_of::type; - template class Sapply : public VectorBase< Rcpp::traits::r_sexptype_traits< - typename ::Rcpp::sugar::sapply_application_result_of::type + typename ::Rcpp::traits::result_of::type >::rtype , true , Sapply > { public: - typedef typename ::Rcpp::sugar::sapply_application_result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; const static int RESULT_R_TYPE = Rcpp::traits::r_sexptype_traits::rtype ; @@ -87,13 +65,13 @@ class Sapply : public VectorBase< template class Sapply : public VectorBase< Rcpp::traits::r_sexptype_traits< - typename ::Rcpp::sugar::sapply_application_result_of::type + typename ::Rcpp::traits::result_of::type >::rtype , true , Sapply > { public: - typedef typename ::Rcpp::sugar::sapply_application_result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; const static int RESULT_R_TYPE = Rcpp::traits::r_sexptype_traits::rtype ; @@ -124,15 +102,15 @@ template inline sugar::Sapply< RTYPE,NA,T,Function, traits::same_type< - typename ::Rcpp::sugar::sapply_application_result_of::type , - typename Rcpp::traits::storage_type< traits::r_sexptype_traits< typename ::Rcpp::sugar::sapply_application_result_of::type >::rtype >::type + typename ::Rcpp::traits::result_of::type , + typename Rcpp::traits::storage_type< traits::r_sexptype_traits< typename ::Rcpp::traits::result_of::type >::rtype >::type >::value > sapply( const Rcpp::VectorBase& t, Function fun ){ return sugar::Sapply::type , - typename Rcpp::traits::storage_type< traits::r_sexptype_traits< typename ::Rcpp::sugar::sapply_application_result_of::type >::rtype >::type + typename ::Rcpp::traits::result_of::type , + typename Rcpp::traits::storage_type< traits::r_sexptype_traits< typename ::Rcpp::traits::result_of::type >::rtype >::type >::value >( t, fun ) ; } diff --git a/inst/include/Rcpp/sugar/functions/self_match.h b/inst/include/Rcpp/sugar/functions/self_match.h index 67dd36cf4..d71aacf94 100644 --- a/inst/include/Rcpp/sugar/functions/self_match.h +++ b/inst/include/Rcpp/sugar/functions/self_match.h @@ -2,7 +2,8 @@ // // self_match.h: Rcpp R/C++ interface class library -- self match // -// Copyright (C) 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -57,7 +58,7 @@ class SelfMatch { inline operator IntegerVector() const { return result ; } private: - typedef RCPP_UNORDERED_MAP HASH ; + typedef std::unordered_map HASH ; typedef SelfInserter Inserter ; HASH hash ; IntegerVector result ; diff --git a/inst/include/Rcpp/sugar/functions/setdiff.h b/inst/include/Rcpp/sugar/functions/setdiff.h index fecc7c6cf..d2886ae5f 100644 --- a/inst/include/Rcpp/sugar/functions/setdiff.h +++ b/inst/include/Rcpp/sugar/functions/setdiff.h @@ -2,7 +2,8 @@ // // setdiff.h: Rcpp R/C++ interface class library -- setdiff // -// Copyright (C) 2012 - 2014 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -60,7 +61,7 @@ namespace sugar{ } private: - typedef RCPP_UNORDERED_SET SET ; + typedef std::unordered_set SET ; typedef typename SET::const_iterator ITERATOR ; SET lhs_set ; SET rhs_set ; @@ -89,7 +90,7 @@ namespace sugar{ } private: - typedef RCPP_UNORDERED_SET SET ; + typedef std::unordered_set SET ; typedef typename SET::const_iterator ITERATOR ; SET lhs_set ; SET rhs_set ; @@ -123,7 +124,7 @@ namespace sugar{ } private: - typedef RCPP_UNORDERED_SET SET ; + typedef std::unordered_set SET ; typedef typename SET::const_iterator ITERATOR ; SET intersect ; @@ -148,7 +149,7 @@ namespace sugar{ } private: - typedef RCPP_UNORDERED_SET SET ; + typedef std::unordered_set SET ; typedef typename SET::const_iterator ITERATOR ; SET result ; diff --git a/inst/include/Rcpp/sugar/functions/sum.h b/inst/include/Rcpp/sugar/functions/sum.h index 601a65a73..fac5d10d4 100644 --- a/inst/include/Rcpp/sugar/functions/sum.h +++ b/inst/include/Rcpp/sugar/functions/sum.h @@ -2,7 +2,8 @@ // // sum.h: Rcpp R/C++ interface class library -- sum // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -42,7 +43,7 @@ class Sum : public Lazy< typename Rcpp::traits::storage_type::type , Sum< current = object[i] ; if( Rcpp::traits::is_na(current) ) return Rcpp::traits::get_na() ; - result += current ; + result = RCPP_SAFE_ADD(result, current); } return result ; } @@ -84,7 +85,7 @@ class Sum : public Lazy< typename Rcpp::traits::storage_type -class Table { -public: - typedef typename Rcpp::traits::storage_type::type STORAGE ; - - Table( const TABLE_T& table ): hash() { - std::for_each( table.begin(), table.end(), Inserter(hash) ) ; - } - - inline operator IntegerVector() const { - R_xlen_t n = hash.size() ; - IntegerVector result = no_init(n) ; - CharacterVector names = no_init(n) ; - std::for_each( hash.begin(), hash.end(), Grabber(result, names) ) ; - result.names() = names ; - return result ; - } - -private: - typedef RCPP_UNORDERED_MAP >HASH ; - typedef CountInserter Inserter ; - HASH hash ; -}; - -#else - template class Table { public: @@ -109,7 +78,7 @@ class Table { } private: - typedef RCPP_UNORDERED_MAP HASH ; + typedef std::unordered_map HASH ; typedef CountInserter Inserter ; HASH hash ; @@ -118,8 +87,6 @@ class Table { }; -#endif // USING_RCPP_MAP - } // sugar template @@ -130,4 +97,3 @@ inline IntegerVector table( const VectorBase& x ){ } // Rcpp #endif - diff --git a/inst/include/Rcpp/sugar/matrix/outer.h b/inst/include/Rcpp/sugar/matrix/outer.h index 1c114862a..5a7b4aa03 100644 --- a/inst/include/Rcpp/sugar/matrix/outer.h +++ b/inst/include/Rcpp/sugar/matrix/outer.h @@ -2,7 +2,8 @@ // // outer.h: Rcpp R/C++ interface class library -- outer // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -31,13 +32,13 @@ template class Outer : public MatrixBase< Rcpp::traits::r_sexptype_traits< - typename ::Rcpp::traits::result_of::type + typename ::Rcpp::traits::result_of::type >::rtype , true , Outer > { public: - typedef typename ::Rcpp::traits::result_of::type result_type ; + typedef typename ::Rcpp::traits::result_of::type result_type ; const static int RESULT_R_TYPE = Rcpp::traits::r_sexptype_traits::rtype ; diff --git a/inst/include/Rcpp/sugar/operators/Comparator_With_One_Value.h b/inst/include/Rcpp/sugar/operators/Comparator_With_One_Value.h index 5d3caaa5b..365432c5f 100644 --- a/inst/include/Rcpp/sugar/operators/Comparator_With_One_Value.h +++ b/inst/include/Rcpp/sugar/operators/Comparator_With_One_Value.h @@ -2,7 +2,8 @@ // // LessThan.h: Rcpp R/C++ interface class library -- vector operators // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -56,7 +57,7 @@ class Comparator_With_One_Value : public ::Rcpp::VectorBase< LGLSXP, true, Compa inline int rhs_is_na(int i) const { return rhs ; } inline int rhs_is_not_na(int i) const { STORAGE x = lhs[i] ; - return Rcpp::traits::is_na(x) ? x : op( x, rhs ) ; + return Rcpp::traits::is_na(x) ? NA_INTEGER : op( x, rhs ) ; } } ; diff --git a/inst/include/Rcpp/sugar/operators/minus.h b/inst/include/Rcpp/sugar/operators/minus.h index f94061726..04bfcb7dc 100644 --- a/inst/include/Rcpp/sugar/operators/minus.h +++ b/inst/include/Rcpp/sugar/operators/minus.h @@ -2,7 +2,8 @@ // // minus.h: Rcpp R/C++ interface class library -- operator- // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -42,7 +43,7 @@ namespace sugar{ STORAGE x = lhs[i] ; if( Rcpp::traits::is_na( x ) ) return x ; STORAGE y = rhs[i] ; - return Rcpp::traits::is_na( y ) ? y : ( x - y ) ; + return Rcpp::traits::is_na( y ) ? y : RCPP_SAFE_SUB(x, y); } inline R_xlen_t size() const { return lhs.size() ; } @@ -91,7 +92,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE y = rhs[i] ; if( Rcpp::traits::is_na( y ) ) return y ; - return lhs[i] - y ; + return lhs[i] - y; } inline R_xlen_t size() const { return lhs.size() ; } @@ -140,7 +141,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE x = lhs[i] ; if( Rcpp::traits::is_na( x ) ) return x ; - return x - rhs[i] ; + return x - rhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } @@ -188,7 +189,7 @@ namespace sugar{ lhs(lhs_.get_ref()), rhs(rhs_.get_ref()) {} inline STORAGE operator[]( R_xlen_t i ) const { - return lhs[i] - rhs[i] ; + return lhs[i] - rhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } @@ -238,7 +239,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { if( rhs_na ) return rhs ; STORAGE x = lhs[i] ; - return Rcpp::traits::is_na(x) ? x : (x - rhs) ; + return Rcpp::traits::is_na(x) ? x : RCPP_SAFE_SUB(x, rhs); } inline R_xlen_t size() const { return lhs.size() ; } @@ -284,7 +285,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { if( rhs_na ) return rhs ; STORAGE x = lhs[i] ; - return Rcpp::traits::is_na(x) ? x : (x - rhs) ; + return Rcpp::traits::is_na(x) ? x : x - rhs; } inline R_xlen_t size() const { return lhs.size() ; } @@ -333,7 +334,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { if( lhs_na ) return lhs ; - return lhs - rhs[i] ; + return RCPP_SAFE_SUB(lhs, rhs[i]); } inline R_xlen_t size() const { return rhs.size() ; } @@ -370,14 +371,14 @@ namespace sugar{ public: typedef typename Rcpp::VectorBase VEC_TYPE ; typedef typename traits::storage_type::type STORAGE ; - typedef typename Rcpp::traits::Extractor::type VEC_EXT ; + typedef typename Rcpp::traits::Extractor::type VEC_EXT ; Minus_Primitive_Vector( STORAGE lhs_, const VEC_TYPE& rhs_ ) : lhs(lhs_), rhs(rhs_.get_ref()), lhs_na( Rcpp::traits::is_na(lhs_) ) {} inline STORAGE operator[]( R_xlen_t i ) const { if( lhs_na ) return lhs ; - return lhs - rhs[i] ; + return lhs - rhs[i]; } inline R_xlen_t size() const { return rhs.size() ; } diff --git a/inst/include/Rcpp/sugar/operators/plus.h b/inst/include/Rcpp/sugar/operators/plus.h index 70f9f0e44..9434f4853 100644 --- a/inst/include/Rcpp/sugar/operators/plus.h +++ b/inst/include/Rcpp/sugar/operators/plus.h @@ -2,7 +2,8 @@ // // plus.h: Rcpp R/C++ interface class library -- operator+ // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -42,7 +43,7 @@ namespace sugar{ STORAGE lhs_ = lhs[i] ; if( traits::is_na(lhs_) ) return lhs_ ; STORAGE rhs_ = rhs[i] ; - return traits::is_na(rhs_) ? rhs_ : (lhs_ + rhs_) ; + return traits::is_na(rhs_) ? rhs_ : RCPP_SAFE_ADD(lhs_, rhs_); } inline R_xlen_t size() const { return lhs.size() ; } @@ -99,7 +100,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE rhs_ = rhs[i] ; if( traits::is_na(rhs_) ) return rhs_ ; - return lhs[i] + rhs_ ; + return lhs[i] + rhs_; } inline R_xlen_t size() const { return lhs.size() ; } @@ -152,7 +153,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE lhs_ = lhs[i] ; if( traits::is_na(lhs_) ) return lhs_ ; - return lhs_ + rhs[i] ; + return lhs_ + rhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } @@ -204,7 +205,7 @@ namespace sugar{ lhs(lhs_.get_ref()), rhs(rhs_.get_ref()){} inline STORAGE operator[]( R_xlen_t i ) const { - return lhs[i] + rhs[i] ; + return lhs[i] + rhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } @@ -250,7 +251,6 @@ namespace sugar{ public: typedef typename Rcpp::VectorBase VEC_TYPE ; typedef typename traits::storage_type::type STORAGE ; - typedef typename Rcpp::traits::Extractor< RTYPE, NA, T>::type EXT ; Plus_Vector_Primitive( const VEC_TYPE& lhs_, STORAGE rhs_ ) : @@ -260,7 +260,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { if( rhs_na ) return rhs ; STORAGE x = lhs[i] ; - return Rcpp::traits::is_na(x) ? x : (x + rhs) ; + return Rcpp::traits::is_na(x) ? x : RCPP_SAFE_ADD(x, rhs); } inline R_xlen_t size() const { return lhs.size() ; } @@ -308,7 +308,7 @@ namespace sugar{ lhs(lhs_.get_ref()), rhs(rhs_), rhs_na( Rcpp::traits::is_na(rhs_) ) {} inline STORAGE operator[]( R_xlen_t i ) const { - return rhs_na ? rhs : (rhs + lhs[i] ) ; + return rhs_na ? rhs : (rhs + lhs[i]); } inline R_xlen_t size() const { return lhs.size() ; } @@ -360,7 +360,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE x = lhs[i] ; - return Rcpp::traits::is_na(x) ? x : (x + rhs) ; + return Rcpp::traits::is_na(x) ? x : x + rhs; } inline R_xlen_t size() const { return lhs.size() ; } @@ -407,7 +407,7 @@ namespace sugar{ lhs(lhs_.get_ref()), rhs(rhs_) {} inline STORAGE operator[]( R_xlen_t i ) const { - return rhs + lhs[i] ; + return rhs + lhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } diff --git a/inst/include/Rcpp/sugar/operators/times.h b/inst/include/Rcpp/sugar/operators/times.h index d1f335992..54dfe0449 100644 --- a/inst/include/Rcpp/sugar/operators/times.h +++ b/inst/include/Rcpp/sugar/operators/times.h @@ -2,7 +2,8 @@ // // times.h: Rcpp R/C++ interface class library -- operator* // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -43,7 +44,7 @@ namespace sugar{ STORAGE lhs_ = lhs[i] ; if( traits::is_na(lhs_) ) return lhs_ ; STORAGE rhs_ = rhs[i] ; - return traits::is_na(rhs_) ? rhs_ : (lhs_ * rhs_) ; + return traits::is_na(rhs_) ? rhs_ : RCPP_SAFE_MUL(lhs_, rhs_) ; } inline R_xlen_t size() const { return lhs.size() ; } @@ -96,7 +97,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE rhs_ = rhs[i] ; if( traits::is_na(rhs_) ) return rhs_ ; - return lhs[i] * rhs_ ; + return lhs[i] * rhs_; } inline R_xlen_t size() const { return lhs.size() ; } @@ -148,7 +149,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE lhs_ = lhs[i] ; if( traits::is_na(lhs_) ) return lhs_ ; - return lhs_ * rhs[i] ; + return lhs_ * rhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } @@ -197,7 +198,7 @@ namespace sugar{ lhs(lhs_.get_ref()), rhs(rhs_.get_ref()){} inline STORAGE operator[]( R_xlen_t i ) const { - return lhs[i] * rhs[i] ; + return lhs[i] * rhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } @@ -247,7 +248,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { if( rhs_na ) return rhs ; STORAGE x = lhs[i] ; - return Rcpp::traits::is_na(x) ? x : (x * rhs) ; + return Rcpp::traits::is_na(x) ? x : RCPP_SAFE_MUL(x, rhs); } inline R_xlen_t size() const { return lhs.size() ; } @@ -293,7 +294,7 @@ namespace sugar{ lhs(lhs_.get_ref()), rhs(rhs_), rhs_na( Rcpp::traits::is_na(rhs_) ) {} inline STORAGE operator[]( R_xlen_t i ) const { - return rhs_na ? rhs : (rhs * lhs[i] ) ; + return rhs_na ? rhs : (rhs * lhs[i]); } inline R_xlen_t size() const { return lhs.size() ; } @@ -345,7 +346,7 @@ namespace sugar{ inline STORAGE operator[]( R_xlen_t i ) const { STORAGE x = lhs[i] ; - return Rcpp::traits::is_na(x) ? x : (x * rhs) ; + return Rcpp::traits::is_na(x) ? x : x * rhs; } inline R_xlen_t size() const { return lhs.size() ; } @@ -391,7 +392,7 @@ namespace sugar{ lhs(lhs_.get_ref()), rhs(rhs_) {} inline STORAGE operator[]( R_xlen_t i ) const { - return rhs * lhs[i] ; + return rhs * lhs[i]; } inline R_xlen_t size() const { return lhs.size() ; } diff --git a/inst/include/Rcpp/sugar/sets.h b/inst/include/Rcpp/sugar/sets.h index fa432bfd1..402886cd1 100644 --- a/inst/include/Rcpp/sugar/sets.h +++ b/inst/include/Rcpp/sugar/sets.h @@ -1,8 +1,6 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// // sets.h: Rcpp R/C++ interface class library -- // -// Copyright (C) 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -22,40 +20,14 @@ #ifndef Rcpp__sugar__sets_h #define Rcpp__sugar__sets_h -#if __cplusplus >= 201103L - #define RCPP_UNORDERED_SET std::unordered_set - #define RCPP_UNORDERED_MAP std::unordered_map - - namespace std { - template<> - struct hash { - std::size_t operator()(const Rcpp::String& key) const { - return pointer_hasher( key.get_sexp() ) ; - } - hash pointer_hasher ; - }; - } - -#elif defined(HAS_TR1_UNORDERED_SET) - #define RCPP_UNORDERED_SET std::tr1::unordered_set - #define RCPP_UNORDERED_MAP std::tr1::unordered_map - - namespace std { - namespace tr1 { - template<> - struct hash { - std::size_t operator()(const Rcpp::String& key) const { - return pointer_hasher( key.get_sexp() ) ; - } - hash pointer_hasher ; - }; +namespace std { + template<> + struct hash { + std::size_t operator()(const Rcpp::String& key) const { + return pointer_hasher( key.get_sexp() ) ; } - } - - -#else - #define RCPP_UNORDERED_SET std::set - #define RCPP_UNORDERED_MAP std::map -#endif + hash pointer_hasher ; + }; +} #endif diff --git a/inst/include/Rcpp/sugar/sugar.h b/inst/include/Rcpp/sugar/sugar.h index 0e2c2e37b..1bf160ab9 100644 --- a/inst/include/Rcpp/sugar/sugar.h +++ b/inst/include/Rcpp/sugar/sugar.h @@ -2,7 +2,8 @@ // // sugar.h: Rcpp R/C++ interface class library -- main file for Rcpp::sugar // -// Copyright (C) 2010 - 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -23,6 +24,7 @@ #define RCPP_SUGAR_H #include +#include #include #include diff --git a/inst/include/Rcpp/sugar/tools/safe_math.h b/inst/include/Rcpp/sugar/tools/safe_math.h new file mode 100644 index 000000000..46774850d --- /dev/null +++ b/inst/include/Rcpp/sugar/tools/safe_math.h @@ -0,0 +1,134 @@ +// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- +// +// safe_math.h: Rcpp R/C++ interface class library -- +// +// Copyright (C) 2026 Iñaki Ucar +// +// 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 . + +#ifndef Rcpp__sugar__tools_safe_math_h +#define Rcpp__sugar__tools_safe_math_h + +#ifndef safe_math__has_builtin +# ifdef __has_builtin +# define safe_math__has_builtin(x) __has_builtin(x) +# else +# define safe_math__has_builtin(x) 0 +# endif +#endif + +#define RCPP_SAFE_ADD(a, b) Rcpp::sugar::detail::safe_add(a, b, __func__) +#define RCPP_SAFE_SUB(a, b) Rcpp::sugar::detail::safe_sub(a, b, __func__) +#define RCPP_SAFE_MUL(a, b) Rcpp::sugar::detail::safe_mul(a, b, __func__) + +namespace Rcpp { +namespace sugar { +namespace detail { + + inline void stop_overflow(const char* caller) { + if (caller) + Rcpp::stop("[%s] Integer overflow!", caller); + Rcpp::stop("Integer overflow!"); + } + + // Addition + template + inline typename std::enable_if::value, T>::type + safe_add(T a, T b, const char* caller = nullptr) { + #if safe_math__has_builtin(__builtin_add_overflow) + T result; + if (__builtin_add_overflow(a, b, &result)) + stop_overflow(caller); + return result; + #else // fallback + if (std::is_signed::value) { + if ((b > 0 && a > std::numeric_limits::max() - b) || + (b < 0 && a < std::numeric_limits::min() - b)) + stop_overflow(caller); + } else { + if (a > std::numeric_limits::max() - b) + stop_overflow(caller); + } + return a + b; + #endif + } + + template + inline typename std::enable_if::value, T>::type + safe_add(T a, T b, const char* caller = nullptr) { return a + b; } + + // Subtraction + template + inline typename std::enable_if::value, T>::type + safe_sub(T a, T b, const char* caller = nullptr) { + #if safe_math__has_builtin(__builtin_sub_overflow) + T result; + if (__builtin_sub_overflow(a, b, &result)) + stop_overflow(caller); + return result; + #else // fallback + if (std::is_signed::value) { + if ((b < 0 && a > std::numeric_limits::max() + b) || + (b > 0 && a < std::numeric_limits::min() + b)) + stop_overflow(caller); + } else { + if (a < b) + stop_overflow(caller); + } + return a - b; + #endif + } + + template + inline typename std::enable_if::value, T>::type + safe_sub(T a, T b, const char* caller = nullptr) { return a - b; } + + // Multiplication + template + inline typename std::enable_if::value, T>::type + safe_mul(T a, T b, const char* caller = nullptr) { + #if safe_math__has_builtin(__builtin_mul_overflow) + T result; + if (__builtin_mul_overflow(a, b, &result)) + stop_overflow(caller); + return result; + #else // fallback + if (a == 0 || b == 0) return 0; + if (std::is_signed::value) { + if ((a > 0 && b > 0 && a > std::numeric_limits::max() / b) || + (a > 0 && b < 0 && b < std::numeric_limits::min() / a) || + (a < 0 && b > 0 && a < std::numeric_limits::min() / b) || + (a < 0 && b < 0 && a < std::numeric_limits::max() / b)) + stop_overflow(caller); + } else { + if (b > 0 && a > std::numeric_limits::max() / b) + stop_overflow(caller); + } + return a * b; + #endif + } + + template + inline typename std::enable_if::value, T>::type + safe_mul(T a, T b, const char* caller = nullptr) { return a * b; } + +} // namespace detail +} // namespace sugar +} // namespace Rcpp + +#undef safe_math__has_builtin + +#endif diff --git a/inst/include/Rcpp/sugar/undoRmath.h b/inst/include/Rcpp/sugar/undoRmath.h index c718b724a..60d5e866b 100644 --- a/inst/include/Rcpp/sugar/undoRmath.h +++ b/inst/include/Rcpp/sugar/undoRmath.h @@ -146,7 +146,7 @@ #undef rhyper #undef rlnorm #undef rlogis -#undef rnbeta +//#undef rnbeta #undef rnbinom #undef rnchisq #undef rnf diff --git a/inst/include/Rcpp/traits/index_sequence.h b/inst/include/Rcpp/traits/index_sequence.h index 9a1e54b13..4aa64399b 100644 --- a/inst/include/Rcpp/traits/index_sequence.h +++ b/inst/include/Rcpp/traits/index_sequence.h @@ -1,9 +1,6 @@ #ifndef RCPP_TRAITS_INDEX_SEQUENCE_H #define RCPP_TRAITS_INDEX_SEQUENCE_H - -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - namespace Rcpp { namespace traits { /** @@ -23,5 +20,3 @@ namespace traits { } #endif - -#endif diff --git a/inst/include/Rcpp/traits/is_arithmetic.h b/inst/include/Rcpp/traits/is_arithmetic.h index 8cd705113..87541599b 100644 --- a/inst/include/Rcpp/traits/is_arithmetic.h +++ b/inst/include/Rcpp/traits/is_arithmetic.h @@ -3,7 +3,7 @@ // // is_wide_string.h: Rcpp R/C++ interface class library -- traits to help wrap // -// Copyright (C) 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2013 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -58,15 +58,13 @@ namespace traits{ template<> struct is_arithmetic : public true_type { }; - + template<> struct is_arithmetic : public true_type { }; template<> struct is_arithmetic : public true_type { }; -#if defined(RCPP_HAS_LONG_LONG_TYPES) - template<> struct is_arithmetic : public true_type { }; @@ -79,8 +77,6 @@ namespace traits{ template<> struct is_arithmetic : public true_type { }; -#endif - template<> struct is_arithmetic : public true_type { }; diff --git a/inst/include/Rcpp/traits/longlong.h b/inst/include/Rcpp/traits/longlong.h index c9de72ed9..7c9177824 100644 --- a/inst/include/Rcpp/traits/longlong.h +++ b/inst/include/Rcpp/traits/longlong.h @@ -2,7 +2,7 @@ // // longlong.h: Rcpp R/C++ interface class library -- long long traits // -// Copyright (C) 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2013 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -22,8 +22,6 @@ #ifndef RCPP_TRAITS_LONG_LONG_H #define RCPP_TRAITS_LONG_LONG_H -#if defined(RCPP_HAS_LONG_LONG_TYPES) - namespace Rcpp{ namespace traits{ @@ -39,6 +37,5 @@ namespace Rcpp{ template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; } } -#endif #endif diff --git a/inst/include/Rcpp/traits/named_object.h b/inst/include/Rcpp/traits/named_object.h index f3734f3de..e1fd2476a 100644 --- a/inst/include/Rcpp/traits/named_object.h +++ b/inst/include/Rcpp/traits/named_object.h @@ -2,7 +2,7 @@ // named_object.h: Rcpp R/C++ interface class library -- named SEXP // // Copyright (C) 2010 - 2020 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2021 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +// Copyright (C) 2021 - 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -65,18 +65,15 @@ template struct is_named : public false_type{}; template struct is_named< named_object > : public true_type {}; template <> struct is_named< Rcpp::Argument > : public true_type {}; +template struct is_any_named : public false_type {}; +template struct is_any_named : public is_named::type {}; -#if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - template struct is_any_named : public false_type {}; - template struct is_any_named : public is_named::type {}; - - template - struct is_any_named - : public std::conditional< - is_any_named::value, - std::true_type, - is_any_named>::type {}; -#endif +template +struct is_any_named + : public std::conditional< + is_any_named::value, + std::true_type, + is_any_named>::type {}; } // namespace traits } // namespace Rcpp diff --git a/inst/include/Rcpp/traits/r_type_traits.h b/inst/include/Rcpp/traits/r_type_traits.h index 2fbe195c0..17f57340f 100644 --- a/inst/include/Rcpp/traits/r_type_traits.h +++ b/inst/include/Rcpp/traits/r_type_traits.h @@ -141,6 +141,9 @@ template<> struct r_type_traits{ typedef r_type_primitive_tag r_catego template<> struct r_type_traits{ typedef r_type_primitive_tag r_category ; } ; template<> struct r_type_traits{ typedef r_type_string_tag r_category ; } ; template<> struct r_type_traits{ typedef r_type_string_tag r_category ; } ; +#if __cplusplus >= 201703L +template<> struct r_type_traits{ typedef r_type_string_tag r_category ; } ; +#endif template<> struct r_type_traits{ typedef r_type_string_tag r_category ; } ; template<> struct r_type_traits{ typedef r_type_string_tag r_category ; } ; diff --git a/inst/include/Rcpp/traits/result_of.h b/inst/include/Rcpp/traits/result_of.h index 2c3f849e0..a7f931efb 100644 --- a/inst/include/Rcpp/traits/result_of.h +++ b/inst/include/Rcpp/traits/result_of.h @@ -3,7 +3,8 @@ // // result_of.h: Rcpp R/C++ interface class library -- traits to help wrap // -// Copyright (C) 2010 - 2012 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -26,24 +27,20 @@ namespace Rcpp{ namespace traits{ -template +template struct result_of{ - typedef typename T::result_type type ; -} ; - -template -struct result_of< RESULT_TYPE (*)(INPUT_TYPE) >{ - typedef RESULT_TYPE type ; -} ; - -template -struct result_of< RESULT_TYPE (*)(U1, U2) >{ - typedef RESULT_TYPE type ; +#if __cplusplus < 201703L + // deprecated by C++17, removed by C++2020, see https://en.cppreference.com/w/cpp/types/result_of + typedef typename ::std::result_of::type type; +#else + // since C++17, see https://en.cppreference.com/w/cpp/types/result_of + typedef typename ::std::invoke_result::type type; +#endif } ; -template -struct result_of< RESULT_TYPE (*)(U1, U2, U3) >{ - typedef RESULT_TYPE type ; +template +struct result_of{ + typedef typename T::result_type type ; } ; } diff --git a/inst/include/Rcpp/traits/wrap_type_traits.h b/inst/include/Rcpp/traits/wrap_type_traits.h index 5f0b6e512..c170c8b86 100644 --- a/inst/include/Rcpp/traits/wrap_type_traits.h +++ b/inst/include/Rcpp/traits/wrap_type_traits.h @@ -82,6 +82,9 @@ template <> struct wrap_type_traits { typedef wrap_type_primitive_ template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; +#if __cplusplus >= 201703L +template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; +#endif template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; template <> struct wrap_type_traits { typedef wrap_type_primitive_tag wrap_category; } ; diff --git a/inst/include/Rcpp/unwindProtect.h b/inst/include/Rcpp/unwindProtect.h index ce6706842..752a25c1c 100644 --- a/inst/include/Rcpp/unwindProtect.h +++ b/inst/include/Rcpp/unwindProtect.h @@ -2,7 +2,7 @@ // unwind.h: Rcpp R/C++ interface class library -- Unwind Protect // // Copyright (C) 2018 - 2020 RStudio -// Copyright (C) 2021 RStudio, Dirk Eddelbuettel and Iñaki Ucar +// Copyright (C) 2021 - 2025 RStudio, Dirk Eddelbuettel and Iñaki Ucar // // This file is part of Rcpp. // @@ -23,11 +23,7 @@ #define RCPP_UNWINDPROTECT_H #include - -#ifdef RCPP_USING_CXX11 #include -#endif - namespace Rcpp { namespace internal { @@ -45,12 +41,10 @@ inline void maybeJump(void* unwind_data, Rboolean jump) { } } -#ifdef RCPP_USING_CXX11 inline SEXP unwindProtectUnwrap(void* data) { std::function* callback = (std::function*) data; return (*callback)(); } -#endif }} // namespace Rcpp::internal @@ -76,11 +70,9 @@ inline SEXP unwindProtect(SEXP (*callback)(void* data), void* data) { token); } -#ifdef RCPP_USING_CXX11 inline SEXP unwindProtect(std::function callback) { return unwindProtect(&internal::unwindProtectUnwrap, &callback); } -#endif } // namespace Rcpp diff --git a/inst/include/Rcpp/utils/tinyformat.h b/inst/include/Rcpp/utils/tinyformat.h index d920e5fb9..0fd81e1d9 100644 --- a/inst/include/Rcpp/utils/tinyformat.h +++ b/inst/include/Rcpp/utils/tinyformat.h @@ -3,7 +3,7 @@ // tinyformat.h: Rcpp R/C++ interface class library -- tinyformat.h wrapper // // Copyright (C) 2008 - 2009 Dirk Eddelbuettel -// Copyright (C) 2009 - 2017 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2009 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -27,14 +27,7 @@ namespace Rcpp { void stop(const std::string& message); } #define TINYFORMAT_ERROR(REASON) ::Rcpp::stop(REASON) - -#if __cplusplus >= 201103L #define TINYFORMAT_USE_VARIADIC_TEMPLATES -#else -// Don't use C++11 features (support older compilers) -#define TINYFORMAT_NO_VARIADIC_TEMPLATES -#endif - #define TINYFORMAT_ASSERT(cond) do if (!(cond)) ::Rcpp::stop("Assertion failed"); while(0) #include "tinyformat/tinyformat.h" diff --git a/inst/include/Rcpp/vector/ListOf.h b/inst/include/Rcpp/vector/ListOf.h index 7118195e9..46aed35c8 100644 --- a/inst/include/Rcpp/vector/ListOf.h +++ b/inst/include/Rcpp/vector/ListOf.h @@ -1,6 +1,7 @@ // ListOf.h: Rcpp R/C++ interface class library -- templated List container // -// Copyright (C) 2014 Dirk Eddelbuettel, Romain Francois and Kevin Ushey +// Copyright (C) 2014 - 2025 Dirk Eddelbuettel, Romain François and Kevin Ushey +// Copyright (C) 2026 Dirk Eddelbuettel, Romain François, Kevin Ushey and Iñaki Ucar // // This file is part of Rcpp. // @@ -24,9 +25,9 @@ namespace Rcpp { template class ListOf - : public NamesProxyPolicy - , public AttributeProxyPolicy - , public RObjectMethods + : public NamesProxyPolicy> + , public AttributeProxyPolicy> + , public RObjectMethods> { public: diff --git a/inst/include/Rcpp/vector/Vector.h b/inst/include/Rcpp/vector/Vector.h index 2ce4c18b2..76bc56020 100644 --- a/inst/include/Rcpp/vector/Vector.h +++ b/inst/include/Rcpp/vector/Vector.h @@ -1,6 +1,6 @@ // Vector.h: Rcpp R/C++ interface class library -- vectors // -// Copyright (C) 2010 - 2023 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -236,11 +236,9 @@ class Vector : std::transform( first, last, begin(), func) ; } -#ifdef HAS_CXX0X_INITIALIZER_LIST Vector( std::initializer_list list ) { assign( list.begin() , list.end() ) ; } -#endif template Vector& operator=( const T& x) { @@ -331,7 +329,7 @@ class Vector : } inline iterator begin() { return cache.get() ; } - inline iterator end() { return cache.get() + static_cast(size()) ; } + inline iterator end() { return cache.get() + size(); } inline const_iterator begin() const{ return cache.get_const() ; } inline const_iterator end() const{ return cache.get_const() + size() ; } inline const_iterator cbegin() const{ return cache.get_const() ; } @@ -347,10 +345,10 @@ class Vector : return cache.ref( offset(i) ) ; } - inline Proxy at( const size_t& i) { + inline Proxy at( const size_t& i) { // #nocov start return cache.ref( offset(i) ) ; } - inline const_Proxy at( const size_t& i) const { // #nocov start + inline const_Proxy at( const size_t& i) const { return cache.ref( offset(i) ) ; } // #nocov end @@ -1122,55 +1120,55 @@ class Vector : return Vector( 0 ) ; } - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - public: - template - static Vector create(const T&... t){ - return create__dispatch( typename traits::integral_constant::value - >::type(), t... ) ; - } +public: + template + static Vector create(const T&... t){ + return create__dispatch( typename traits::integral_constant::value + >::type(), t... ) ; + } - private: - template - static Vector create__dispatch(traits::false_type, const T&... t){ - Vector res(sizeof...(T)) ; - iterator it(res.begin()); - create_dispatch_impl(it, t...); - return res; - } - template - static Vector create__dispatch( traits::true_type, const T&... t) { - Vector res(sizeof...(T)) ; - Shield names(::Rf_allocVector(STRSXP, sizeof...(T))); - int index = 0; - iterator it(res.begin()); - replace_element_impl(it, names, index, t...); - res.attr("names") = names; - return res; - } - template - static void create_dispatch_impl(iterator& it, const T& t) { - *it = converter_type::get(t); - } +private: + template + static Vector create__dispatch(traits::false_type, const T&... t){ + Vector res(sizeof...(T)) ; + iterator it(res.begin()); + create_dispatch_impl(it, t...); + return res; + } - template - static void create_dispatch_impl(iterator& it, const T& t, const TArgs&... args) { - *it = converter_type::get(t); - create_dispatch_impl(++it, args...); - } - template - static void replace_element_impl(iterator& it, Shield& names, int& index, const T& t) { - replace_element(it, names, index, t); - } - template - static void replace_element_impl(iterator& it, Shield& names, int& index, const T& t, const TArgs&... args) { - replace_element(it, names, index, t); - replace_element_impl(++it, names, ++index, args...); - } - #else - #include - #endif + template + static Vector create__dispatch( traits::true_type, const T&... t) { + Vector res(sizeof...(T)) ; + Shield names(::Rf_allocVector(STRSXP, sizeof...(T))); + int index = 0; + iterator it(res.begin()); + replace_element_impl(it, names, index, t...); + res.attr("names") = names; + return res; + } + + template + static void create_dispatch_impl(iterator& it, const T& t) { + *it = converter_type::get(t); + } + + template + static void create_dispatch_impl(iterator& it, const T& t, const TArgs&... args) { + *it = converter_type::get(t); + create_dispatch_impl(++it, args...); + } + + template + static void replace_element_impl(iterator& it, Shield& names, int& index, const T& t) { + replace_element(it, names, index, t); + } + + template + static void replace_element_impl(iterator& it, Shield& names, int& index, const T& t, const TArgs&... args) { + replace_element(it, names, index, t); + replace_element_impl(++it, names, ++index, args...); + } public: diff --git a/inst/include/Rcpp/vector/proxy.h b/inst/include/Rcpp/vector/proxy.h index 015b77756..296b93001 100644 --- a/inst/include/Rcpp/vector/proxy.h +++ b/inst/include/Rcpp/vector/proxy.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // proxy.h: Rcpp R/C++ interface class library -- proxies // -// Copyright (C) 2010 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -182,7 +181,7 @@ namespace internal{ R_xlen_t index = 0 ; try{ index = parent.offset(name) ; - parent[ index ] = rhs ; + parent[ index ] = rhs ; // #nocov } catch( const index_out_of_bounds& ex ){ parent.push_back( rhs, name ); } diff --git a/inst/include/Rcpp/vector/traits.h b/inst/include/Rcpp/vector/traits.h index c6d76d694..3e1dcecec 100644 --- a/inst/include/Rcpp/vector/traits.h +++ b/inst/include/Rcpp/vector/traits.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // traits.h: Rcpp R/C++ interface class library -- support traits for vector // -// Copyright (C) 2010 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -56,7 +55,7 @@ namespace traits{ void check_index(R_xlen_t i) const { #ifndef RCPP_NO_BOUNDS_CHECK if (i >= size) { - warning("subscript out of bounds (index %s >= vector size %s)", i, size); + warning("subscript out of bounds (index %s >= vector size %s)", i, size); // #nocov } #endif } @@ -94,7 +93,7 @@ namespace traits{ void check_index(R_xlen_t i) const { #ifndef RCPP_NO_BOUNDS_CHECK if (i >= p->size()) { - warning("subscript out of bounds (index %s >= vector size %s)", i, p->size()); + warning("subscript out of bounds (index %s >= vector size %s)", i, p->size()); // #nocov } #endif } diff --git a/inst/include/RcppCommon.h b/inst/include/RcppCommon.h index 5cbe895b5..ea23f5e82 100644 --- a/inst/include/RcppCommon.h +++ b/inst/include/RcppCommon.h @@ -1,10 +1,9 @@ -// // RcppCommon.h: Rcpp R/C++ interface class library -- common include and defines statements // // Copyright (C) 2008 - 2009 Dirk Eddelbuettel // Copyright (C) 2009 - 2020 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2021 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +// Copyright (C) 2021 - 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -27,6 +26,7 @@ // #define RCPP_DEBUG_LEVEL 1 // #define RCPP_DEBUG_MODULE_LEVEL 1 +#include #include #include @@ -54,6 +54,9 @@ namespace Rcpp { #include #include #include +#if __cplusplus >= 201703L +#include +#endif #include #include #include @@ -69,8 +72,6 @@ namespace Rcpp { #include #include #include -#include -#include #include #include @@ -130,9 +131,7 @@ namespace Rcpp { #include #include -#ifdef RCPP_USING_UNWIND_PROTECT - #include -#endif +#include #include #include @@ -188,4 +187,6 @@ namespace Rcpp { #include +#include + #endif diff --git a/inst/skeleton/zzz.R b/inst/skeleton/zzz.R index 0161cafed..a2e19a11a 100644 --- a/inst/skeleton/zzz.R +++ b/inst/skeleton/zzz.R @@ -1,16 +1,7 @@ -## Up until R 2.15.0, the require("methods") is needed but (now) -## triggers an warning from R CMD check -#.onLoad <- function(libname, pkgname){ -# #require("methods") ## needed with R <= 2.15.0 -# loadRcppModules() -#} - - -## For R 2.15.1 and later this also works. Note that calling loadModule() triggers +## For R 2.15.1 and later the approach shown here works (as opposed to the now removed +## and long-deprecated `loadRcppModules()`. Note that calling loadModule() triggers ## a load action, so this does not have to be placed in .onLoad() or evalqOnLoad(). loadModule("NumEx", TRUE) loadModule("yada", TRUE) loadModule("stdVector", TRUE) - - diff --git a/inst/tinytest/cpp/Vector.cpp b/inst/tinytest/cpp/Vector.cpp index 4fc26b7e8..92bad7b0c 100644 --- a/inst/tinytest/cpp/Vector.cpp +++ b/inst/tinytest/cpp/Vector.cpp @@ -2,7 +2,8 @@ // // Vector.cpp: Rcpp R/C++ interface class library -- Vector unit tests // -// Copyright (C) 2012 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2025 Dirk Eddelbuettel and Romain François +// Copyright (C) 2026 Dirk Eddelbuettel, Romain François and Iñaki Ucar // // This file is part of Rcpp. // @@ -170,11 +171,7 @@ IntegerVector integer_range_ctor_2(){ } // [[Rcpp::export]] -IntegerVector integer_names_set(){ - IntegerVector y(2) ; - std::vector names(2) ; - names[0] = "foo" ; - names[1] = "bar" ; +IntegerVector integer_names_set(IntegerVector y, SEXP names) { y.names() = names ; return y ; } @@ -896,3 +893,10 @@ double NumericVector_test_out_of_bounds_read(NumericVector v, R_xlen_t i) { SEXP CharacterVector_test_out_of_bounds_read(CharacterVector v, R_xlen_t i) { return v[i]; } + +// [[Rcpp::export]] +NumericVector vec_copy(NumericVector vec1) { + NumericVector vec2(vec1.size()); + std::copy(vec1.begin(), vec1.end(), vec2.begin()); + return vec2; +} diff --git a/inst/tinytest/cpp/attributes_extended.cpp b/inst/tinytest/cpp/attributes_extended.cpp new file mode 100644 index 000000000..0b3165d24 --- /dev/null +++ b/inst/tinytest/cpp/attributes_extended.cpp @@ -0,0 +1,49 @@ +#include +using namespace Rcpp; + +// Test 4.1: Named Export Parameter +// Coverage target: src/attributes.cpp:360 + +// [[Rcpp::export(name = "custom_exported_name")]] +int test_named_export() { return 123; } + +// [[Rcpp::export(name = "another.custom.name")]] +std::string test_named_export_with_dots() { return "dotted name"; } + +// Test 4.2: Unnamed Export Parameter +// Coverage target: src/attributes.cpp:365 + +// [[Rcpp::export(my_custom_name)]] +int test_unnamed_export_param() { return 456; } + +// Test 4.3: RNG Parameter Variations +// Coverage target: src/attributes.cpp:382-383 + +// [[Rcpp::export(rng = true)]] +int test_rng_lowercase_true() { return 789; } + +// [[Rcpp::export(rng = TRUE)]] +int test_rng_uppercase_true() { return 101; } + +// [[Rcpp::export(rng = false)]] +int test_rng_lowercase_false() { return 202; } + +// Test 4.4: Invisible Parameter Variations +// Coverage target: src/attributes.cpp:391-392 + +// [[Rcpp::export(invisible = true)]] +void test_invisible_lowercase_true() { + // Side effect only - returns invisibly +} + +// [[Rcpp::export(invisible = TRUE)]] +void test_invisible_uppercase_true() { + // Side effect only - returns invisibly +} + +// Test 4.5: exportedCppName with Dots +// Coverage target: src/attributes.cpp:373-377 +// This tests the conversion of dots to underscores in C++ names + +// [[Rcpp::export(name = "test.with.dots")]] +int test_cpp_name_conversion() { return 999; } diff --git a/inst/tinytest/cpp/dates.cpp b/inst/tinytest/cpp/dates.cpp index 6c5800e87..a175cc32f 100644 --- a/inst/tinytest/cpp/dates.cpp +++ b/inst/tinytest/cpp/dates.cpp @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // dates.cpp: Rcpp R/C++ interface class library -- Date + Datetime tests // -// Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -245,4 +244,12 @@ bool has_na_dtv(const Rcpp::DatetimeVector d) { return Rcpp::is_true(Rcpp::any(Rcpp::is_na(d))); } +// [[Rcpp::export]] +Rcpp::DateVector default_ctor_datevector() { + return Rcpp::DateVector(); +} +// [[Rcpp::export]] +Rcpp::DatetimeVector default_ctor_datetimevector() { + return Rcpp::DatetimeVector(); +} diff --git a/inst/tinytest/cpp/language.cpp b/inst/tinytest/cpp/language.cpp index c06c8a6fb..68aa58fe4 100644 --- a/inst/tinytest/cpp/language.cpp +++ b/inst/tinytest/cpp/language.cpp @@ -272,3 +272,10 @@ Formula runit_formula_SEXP(SEXP form){ return f; } +// [[Rcpp::export]] +SEXP runit_language_modify(Function f) { + auto v = NumericVector::create(0.0, 1.0); + Rcpp::Language call(f, v); + v[0] = 999.0; + return CADR(call); +} diff --git a/inst/tinytest/cpp/stack.cpp b/inst/tinytest/cpp/stack.cpp index c3fa41789..a4a5c86eb 100644 --- a/inst/tinytest/cpp/stack.cpp +++ b/inst/tinytest/cpp/stack.cpp @@ -2,7 +2,8 @@ // // misc.cpp: Rcpp R/C++ interface class library -- misc unit tests // -// Copyright (C) 2013 - 2022 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2013 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -55,7 +56,7 @@ SEXP testSendInterrupt() { SEXP maybeThrow(void* data) { bool* fail = (bool*) data; if (*fail) - Rf_error("throw!"); + (Rf_error)("throw!"); // prevent masking else return NumericVector::create(42); } @@ -64,10 +65,7 @@ SEXP maybeThrow(void* data) { SEXP testUnwindProtect(Environment indicator, bool fail) { unwindIndicator my_data(indicator); SEXP out = R_NilValue; - -#ifdef RCPP_USING_UNWIND_PROTECT out = Rcpp::unwindProtect(&maybeThrow, &fail); -#endif return out; } @@ -76,11 +74,7 @@ SEXP testUnwindProtect(Environment indicator, bool fail) { SEXP testUnwindProtectLambda(Environment indicator, bool fail) { unwindIndicator my_data(indicator); SEXP out = R_NilValue; - -#ifdef RCPP_USING_UNWIND_PROTECT out = Rcpp::unwindProtect([&] () { return maybeThrow(&fail); }); -#endif - return out; } @@ -99,10 +93,6 @@ struct FunctionObj { SEXP testUnwindProtectFunctionObject(Environment indicator, bool fail) { unwindIndicator my_data(indicator); SEXP out = R_NilValue; - -#ifdef RCPP_USING_UNWIND_PROTECT out = Rcpp::unwindProtect(FunctionObj(10, fail)); -#endif - return out; } diff --git a/inst/tinytest/cpp/sugar.cpp b/inst/tinytest/cpp/sugar.cpp index 3d17bd9e4..80657899a 100644 --- a/inst/tinytest/cpp/sugar.cpp +++ b/inst/tinytest/cpp/sugar.cpp @@ -1,7 +1,8 @@ // sugar.cpp: Rcpp R/C++ interface class library -- sugar unit tests // -// Copyright (C) 2012 - 2022 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2024 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 - 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -22,12 +23,7 @@ using namespace Rcpp ; template - -#if __cplusplus < 201103L -class square : public std::unary_function { -#else class square : public std::function { -#endif public: T operator()( T t) const { return t*t ; } } ; @@ -226,11 +222,58 @@ NumericVector runit_na_omit( NumericVector xx ){ } // [[Rcpp::export]] -List runit_lapply( IntegerVector xx){ +List runit_lapply( NumericVector xx ){ + List res = lapply( xx, square() ); + return res ; +} + +// [[Rcpp::export]] +List runit_lapply_rawfun( NumericVector xx){ + List res = lapply( xx, raw_square ); + return res ; +} + +// [[Rcpp::export]] +List runit_lapply_lambda(NumericVector xx){ + List res = lapply(xx, [](double x) { return x*x; }); + return res; +} + +// [[Rcpp::export]] +List runit_lapply_seq( IntegerVector xx){ List res = lapply( xx, seq_len ); return res ; } +// [[Rcpp::export]] +NumericVector runit_mapply2(NumericVector xx, NumericVector yy){ + NumericVector res = mapply(xx, yy, std::plus()); + return res; +} + +// [[Rcpp::export]] +NumericVector runit_mapply2_lambda(NumericVector xx, NumericVector yy){ + NumericVector res = mapply(xx, yy, [](double x, double y) { return x+y; }); + return res; +} + +// [[Rcpp::export]] +NumericVector runit_mapply3_lambda(NumericVector xx, NumericVector yy, NumericVector zz){ + NumericVector res = mapply(xx, yy, zz, [](double x, double y, double z) { return x+y+z; }); + return res; +} + +// [[Rcpp::export]] +LogicalVector runit_mapply2_logical(NumericVector xx, NumericVector yy){ + return all(mapply(xx, yy, std::plus()) < 100.0); +} + +// [[Rcpp::export]] +List runit_mapply2_list(IntegerVector xx, IntegerVector yy){ + List res = mapply(xx, yy, seq); + return res ; +} + // [[Rcpp::export]] List runit_minus( IntegerVector xx ){ return List::create( @@ -242,6 +285,21 @@ List runit_minus( IntegerVector xx ){ ) ; } +// [[Rcpp::export]] +IntegerVector runit_minus_ivv( IntegerVector x, IntegerVector y ){ + return x - y; +} + +// [[Rcpp::export]] +IntegerVector runit_minus_ivp( IntegerVector x, int y ){ + return x - y; +} + +// [[Rcpp::export]] +IntegerVector runit_minus_ipv( int x, IntegerVector y ){ + return x - y; +} + // [[Rcpp::export]] LogicalVector runit_any_equal_not( NumericVector xx, NumericVector yy){ return any( !( xx == yy) ) ; @@ -258,14 +316,53 @@ List runit_plus( IntegerVector xx ){ } // [[Rcpp::export]] -List runit_plus_seqlen(){ +IntegerVector runit_plus_ivv( IntegerVector x, IntegerVector y ){ + return x + y; +} + +// [[Rcpp::export]] +IntegerVector runit_plus_ivp( IntegerVector x, int y ){ + return x + y; +} + +// [[Rcpp::export]] +IntegerVector runit_plus_ipv( int x, IntegerVector y ){ + return x + y; +} + +// [[Rcpp::export]] +List runit_plus_seqlen(IntegerVector xx){ return List::create( seq_len(10) + 10, 10 + seq_len(10), - seq_len(10) + seq_len(10) + seq_len(10) + seq_len(10), + seq_len(10) + xx, + xx + seq_len(10) ) ; } +// [[Rcpp::export]] +List runit_minus_seqlen(IntegerVector xx){ + return List::create( + seq_len(10) - 10, + 10 - seq_len(10), + seq_len(10) - seq_len(10), + seq_len(10) - xx, + xx - seq_len(10) + ) ; +} + +// [[Rcpp::export]] +List runit_times_seqlen(IntegerVector xx){ + return List::create( + seq_len(10) * 10, + 10 * seq_len(10), + seq_len(10) * seq_len(10), + seq_len(10) * xx, + xx * seq_len(10) + ) ; +} + // [[Rcpp::export]] LogicalVector runit_plus_all( IntegerVector xx ){ return all( (xx+xx) < 10 ) ; @@ -331,6 +428,12 @@ NumericVector runit_sapply_rawfun( NumericVector xx){ return res ; } +// [[Rcpp::export]] +NumericVector runit_sapply_lambda(NumericVector xx){ + NumericVector res = sapply(xx, [](double x) { return x*x; }); + return res; +} + // [[Rcpp::export]] LogicalVector runit_sapply_square( NumericVector xx){ return all( sapply( xx * xx , square() ) < 10.0 ); @@ -379,6 +482,21 @@ List runit_times( IntegerVector xx ){ ) ; } +// [[Rcpp::export]] +IntegerVector runit_times_ivv( IntegerVector x, IntegerVector y ){ + return x * y; +} + +// [[Rcpp::export]] +IntegerVector runit_times_ivp( IntegerVector x, int y ){ + return x * y; +} + +// [[Rcpp::export]] +IntegerVector runit_times_ipv( int x, IntegerVector y ){ + return x * y; +} + // [[Rcpp::export]] List runit_divides( NumericVector xx ){ return List::create( @@ -448,6 +566,12 @@ NumericMatrix runit_outer( NumericVector xx, NumericVector yy){ return m ; } +// [[Rcpp::export]] +NumericMatrix runit_outer_lambda(NumericVector xx, NumericVector yy){ + NumericMatrix m = outer(xx, yy, [](double x, double y) { return x + y; }); + return m ; +} + // [[Rcpp::export]] List runit_row( NumericMatrix xx ){ return List::create( @@ -549,16 +673,27 @@ List runit_log1p( NumericVector xx){ } // [[Rcpp::export]] -double runit_sum( NumericVector xx){ +double runit_sum_nv( NumericVector xx){ + return sum( xx ) ; +} + +// [[Rcpp::export]] +int runit_sum_iv( IntegerVector xx){ return sum( xx ) ; } // [[Rcpp::export]] -NumericVector runit_cumsum( NumericVector xx ){ +NumericVector runit_cumsum_nv( NumericVector xx ){ NumericVector res = cumsum( xx ) ; return res ; } +// [[Rcpp::export]] +IntegerVector runit_cumsum_iv( IntegerVector xx ){ + IntegerVector res = cumsum( xx ) ; + return res ; +} + // [[Rcpp::export]] List runit_asvector( NumericMatrix z, NumericVector x, NumericVector y){ return List::create( diff --git a/inst/include/Rcpp/module/Module_generated_class_signature.h b/inst/tinytest/cpp/sugar_safe_math.cpp similarity index 57% rename from inst/include/Rcpp/module/Module_generated_class_signature.h rename to inst/tinytest/cpp/sugar_safe_math.cpp index 363d0cb1d..9677184b9 100644 --- a/inst/include/Rcpp/module/Module_generated_class_signature.h +++ b/inst/tinytest/cpp/sugar_safe_math.cpp @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Module_generated_Constructor.h: Rcpp R/C++ interface class library -- Rcpp modules + +// sugar_safe_math.cpp: Rcpp R/C++ interface class library -- safe math unit tests // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2026 Iñaki Ucar // // This file is part of Rcpp. // @@ -19,16 +18,19 @@ // You should have received a copy of the GNU General Public License // along with Rcpp. If not, see . -#ifndef Rcpp_Module_generated_class_signature_h -#define Rcpp_Module_generated_class_signature_h +#include -inline bool yes( SEXP* /*args*/, int /* nargs */ ){ - return true ; +// [[Rcpp::export]] +int safe_add(int a, int b){ + return RCPP_SAFE_ADD(a, b); } -template -bool yes_arity( SEXP* /* args */ , int nargs){ - return nargs == n ; +// [[Rcpp::export]] +int safe_sub(int a, int b){ + return RCPP_SAFE_SUB(a, b); } -#endif +// [[Rcpp::export]] +int safe_mul(int a, int b){ + return RCPP_SAFE_MUL(a, b); +} diff --git a/inst/tinytest/cpp/sugar_safe_math_fallback.cpp b/inst/tinytest/cpp/sugar_safe_math_fallback.cpp new file mode 100644 index 000000000..15fdcc2e9 --- /dev/null +++ b/inst/tinytest/cpp/sugar_safe_math_fallback.cpp @@ -0,0 +1,37 @@ + +// sugar_safe_math.cpp: Rcpp R/C++ interface class library -- safe math unit tests +// +// Copyright (C) 2026 Iñaki Ucar +// +// 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 . + +#define safe_math__has_builtin(x) 0 +#include + +// [[Rcpp::export]] +int safe_add_fallback(int a, int b){ + return RCPP_SAFE_ADD(a, b); +} + +// [[Rcpp::export]] +int safe_sub_fallback(int a, int b){ + return RCPP_SAFE_SUB(a, b); +} + +// [[Rcpp::export]] +int safe_mul_fallback(int a, int b){ + return RCPP_SAFE_MUL(a, b); +} diff --git a/inst/tinytest/cpp/wrap.cpp b/inst/tinytest/cpp/wrap.cpp index 1f42f62d5..eefd5c2d9 100644 --- a/inst/tinytest/cpp/wrap.cpp +++ b/inst/tinytest/cpp/wrap.cpp @@ -2,7 +2,8 @@ // // wrap.cpp: Rcpp R/C++ interface class library -- wrap unit tests // -// Copyright (C) 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2013 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -168,13 +169,9 @@ SEXP nonnull_const_char(){ return wrap(p) ; } -#ifdef RCPP_USING_CXX11 -// [[Rcpp::plugins(cpp11)]] -#endif - // [[Rcpp::export]] IntegerVector unordered_map_string_int(){ - RCPP_UNORDERED_MAP< std::string, int > m ; + std::unordered_map< std::string, int > m ; m["b"] = 100; m["a"] = 200; m["c"] = 300; @@ -183,7 +180,7 @@ IntegerVector unordered_map_string_int(){ // [[Rcpp::export]] IntegerVector unordered_map_rcpp_string_int(StringVector v){ - RCPP_UNORDERED_MAP< String, int > m ; + std::unordered_map< String, int > m ; m[v[0]] = 200; m[v[1]] = 100; m[v[2]] = 300; @@ -192,7 +189,7 @@ IntegerVector unordered_map_rcpp_string_int(StringVector v){ // [[Rcpp::export]] LogicalVector unordered_set_rcpp_string(StringVector x) { - RCPP_UNORDERED_SET seen; + std::unordered_set seen; LogicalVector out(x.size()); for (int i = 0; i < x.size(); i++) { out[i] = !seen.insert(x[i]).second; @@ -202,7 +199,7 @@ LogicalVector unordered_set_rcpp_string(StringVector x) { // [[Rcpp::export]] NumericVector unordered_map_string_double(){ - RCPP_UNORDERED_MAP m ; + std::unordered_map m ; m["b"] = 100; m["a"] = 200; m["c"] = 300; @@ -211,7 +208,7 @@ NumericVector unordered_map_string_double(){ // [[Rcpp::export]] LogicalVector unordered_map_string_bool(){ - RCPP_UNORDERED_MAP m ; + std::unordered_map m ; m["b"] = true; m["a"] = false; m["c"] = true; @@ -220,7 +217,7 @@ LogicalVector unordered_map_string_bool(){ // [[Rcpp::export]] RawVector unordered_map_string_Rbyte(){ - RCPP_UNORDERED_MAP m ; + std::unordered_map m ; m["b"] = (Rbyte)0; m["a"] = (Rbyte)1; m["c"] = (Rbyte)2; @@ -229,7 +226,7 @@ RawVector unordered_map_string_Rbyte(){ // [[Rcpp::export]] CharacterVector unordered_map_string_string(){ - RCPP_UNORDERED_MAP m ; + std::unordered_map m ; m["b"] = "foo" ; m["a"] = "bar" ; m["c"] = "bling" ; @@ -238,7 +235,7 @@ CharacterVector unordered_map_string_string(){ // [[Rcpp::export]] List unordered_map_string_generic(){ - RCPP_UNORDERED_MAP< std::string,std::vector > m ; + std::unordered_map< std::string,std::vector > m ; std::vector b; b.push_back(1); b.push_back(2); m["b"] = b ; std::vector a; a.push_back(1); a.push_back(2); a.push_back(2); m["a"] = a; std::vector c; c.push_back(1); c.push_back(2); c.push_back(2); c.push_back(2); m["c"] = c; @@ -304,3 +301,10 @@ SEXP vector_Foo(){ vec[1] = Foo( 3 ) ; return wrap(vec) ; } + +// [[Rcpp::plugins(cpp17)]] +// [[Rcpp::export]] +SEXP test_wrap_string_view(){ + std::string_view sv = "test string value" ; + return wrap(sv) ; +} diff --git a/inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp b/inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp index a6beb9b53..4b018f29f 100644 --- a/inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp +++ b/inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp @@ -43,7 +43,7 @@ RcppExport SEXP _testRcppInterfaceExporter_test_cpp_interface(SEXP xSEXP, SEXP f if (rcpp_isError_gen) { SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); UNPROTECT(1); - Rf_error("%s", CHAR(rcpp_msgSEXP_gen)); + (Rf_error)("%s", CHAR(rcpp_msgSEXP_gen)); } UNPROTECT(1); return rcpp_result_gen; diff --git a/inst/tinytest/testRcppInterfaceUser/tests/tests.R b/inst/tinytest/testRcppInterfaceUser/tests/tests.R index effb2e482..f5885bd98 100644 --- a/inst/tinytest/testRcppInterfaceUser/tests/tests.R +++ b/inst/tinytest/testRcppInterfaceUser/tests/tests.R @@ -43,9 +43,7 @@ x <- withRestarts( stopifnot(identical(x, "value")) -if (getRversion() >= "3.5.0") { - stopifnot( - testRcppInterfaceUser::peek_flag("cpp_interface_downstream"), - testRcppInterfaceExporter::peek_flag("cpp_interface_upstream") - ) -} +stopifnot( + testRcppInterfaceUser::peek_flag("cpp_interface_downstream"), + testRcppInterfaceExporter::peek_flag("cpp_interface_upstream") +) diff --git a/inst/tinytest/testRcppModule/R/zzz.R b/inst/tinytest/testRcppModule/R/zzz.R index f23b84272..e26fbae91 100644 --- a/inst/tinytest/testRcppModule/R/zzz.R +++ b/inst/tinytest/testRcppModule/R/zzz.R @@ -1,11 +1,6 @@ -# -#.onLoad <- function(libname, pkgname){ -# loadRcppModules() -#} - -## For R 2.15.1 and later this also works. Note that calling loadModule() triggers +## For R 2.15.1 and later the approach shown here works (as opposed to the now removed +## and long-deprecated `loadRcppModules()`. Note that calling loadModule() triggers ## a load action, so this does not have to be placed in .onLoad() or evalqOnLoad(). loadModule("RcppModuleNumEx", TRUE) loadModule("RcppModuleWorld", TRUE) loadModule("stdVector", TRUE) - diff --git a/inst/tinytest/test_attribute_package.R b/inst/tinytest/test_attribute_package.R index 563038149..92671acaf 100644 --- a/inst/tinytest/test_attribute_package.R +++ b/inst/tinytest/test_attribute_package.R @@ -38,10 +38,10 @@ require(pkg, lib.loc = "templib", character.only = TRUE) # Test Package options(verbose=TRUE) -expect_equal(test_no_attributes(list("{A}"), FALSE),list("{A}", FALSE)) +expect_equal(test_no_attributes(list("{A}"), FALSE),list("{A}", FALSE)) expect_equal(test_signature(),list("{A}", TRUE)) expect_equal(test_rng_false_signature_invisible_true(),list("{A}", TRUE)) -expect_equal(test_rng_false(list("{A}"), FALSE),list("{A}", FALSE)) +expect_equal(test_rng_false(list("{A}"), FALSE),list("{A}", FALSE)) expect_equal(test_rng_true(list("{A}"), FALSE),list("{A}", FALSE)) expect_equal(test_rng_true_signature(),list("{A}", TRUE)) expect_equal(test_invisible_true_rng_true(list("{A}"), FALSE),list("{A}", FALSE)) @@ -105,7 +105,7 @@ expect_error({ # test 3, from Enchufa2 # This third example should not compile because of missing end bracket } -# The bracket within the signature is taken as the end bracket, which results in +# The bracket within the signature is taken as the end bracket, which results in # invalid R code. There are some additional warnings due to the incorrect syntax expect_warning({ expect_error({ diff --git a/inst/tinytest/test_attributes_extended.R b/inst/tinytest/test_attributes_extended.R new file mode 100644 index 000000000..dea80a564 --- /dev/null +++ b/inst/tinytest/test_attributes_extended.R @@ -0,0 +1,42 @@ +## Copyright (C) 2026 Dirk Eddelbuettel +## +## 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/attributes_extended.cpp") + +## Test named exports +expect_equal(custom_exported_name(), 123) +expect_equal(another.custom.name(), "dotted name") + +## Test unnamed export parameter +expect_equal(my_custom_name(), 456) + +## Test RNG parameters +expect_equal(test_rng_lowercase_true(), 789) +expect_equal(test_rng_uppercase_true(), 101) +expect_equal(test_rng_lowercase_false(), 202) + +## Test invisible parameters (should return invisibly) +result1 <- withVisible(test_invisible_lowercase_true()) +expect_false(result1$visible) + +result2 <- withVisible(test_invisible_uppercase_true()) +expect_false(result2$visible) + +## Test C++ name conversion (dots to underscores) +expect_equal(test.with.dots(), 999) diff --git a/inst/tinytest/test_compile_attributes_errors.R b/inst/tinytest/test_compile_attributes_errors.R new file mode 100644 index 000000000..445aacaa1 --- /dev/null +++ b/inst/tinytest/test_compile_attributes_errors.R @@ -0,0 +1,33 @@ +## Copyright (C) 2026 Dirk Eddelbuettel +## +## 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +## Test 3.1: Missing DESCRIPTION File +## Coverage target: R/Attributes.R:420 +tmpdir <- tempfile() +dir.create(tmpdir) +expect_error(compileAttributes(tmpdir), "must refer to the directory containing an R package") +unlink(tmpdir, recursive = TRUE) + +## Test 3.2: Missing NAMESPACE File +## Coverage target: R/Attributes.R:432 +tmpdir <- tempfile() +dir.create(tmpdir) +writeLines("Package: TestPkg", file.path(tmpdir, "DESCRIPTION")) +expect_error(compileAttributes(tmpdir), "must refer to the directory containing an R package") +unlink(tmpdir, recursive = TRUE) diff --git a/inst/tinytest/test_cppfunction_errors.R b/inst/tinytest/test_cppfunction_errors.R new file mode 100644 index 000000000..c8b63df1d --- /dev/null +++ b/inst/tinytest/test_cppfunction_errors.R @@ -0,0 +1,36 @@ +## Copyright (C) 2026 Dirk Eddelbuettel +## +## 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +## Test 2.1: No Function Definition +## Coverage target: R/Attributes.R:326 +code <- "int x = 5;" # No function, just a variable +expect_error(cppFunction(code), "No function definition found") + +## -- Next test goes awry as of 2026-March so parking it for now +## ## Test 2.2: Multiple Function Definitions +## ## Coverage target: R/Attributes.R:328 +## code <- " +## // [[Rcpp::export]] +## int foo() { return 1; } + +## // [[Rcpp::export]] +## int bar() { return 2; } +## " +## ## compilation dies sooner so we never actually see the messages +## expect_error(cppFunction(code)) #, "More than one function definition") diff --git a/inst/tinytest/test_date.R b/inst/tinytest/test_date.R index 84891ae55..0c5ffda01 100644 --- a/inst/tinytest/test_date.R +++ b/inst/tinytest/test_date.R @@ -1,5 +1,5 @@ -## Copyright (C) 2010 - 2019 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois ## ## This file is part of Rcpp. ## @@ -194,7 +194,7 @@ expect_equal(Datetime_format(d,"%Y-%m-%d %H:%M:%S"), format(d, "%Y-%m-%d %H:%M:%OS"), info="Datetime.formating.default") expect_equal(Datetime_format(d, "%Y/%m/%d %H:%M:%S"), - format(d, "%Y/%m/%d %H:%M:%OS"), + format(d, "%Y/%m/%d %H:%M:%OS6"), info="Datetime.formating.given.format") expect_equal(Datetime_ostream(d), format(d, "%Y-%m-%d %H:%M:%OS"), @@ -241,3 +241,15 @@ dvt <- Sys.time() + 0:2 expect_true(has_na_dtv(dvt) == FALSE, info="DatetimeVector.NAtest.withoutNA") dvt[1] <- NA expect_true(has_na_dtv(dvt) == TRUE, info="DatetimeVector.NAtest.withNA") + +## default ctor: date +dv <- default_ctor_datevector() +expect_true(inherits(dv, "Date")) +expect_equal(length(dv), 0L) +expect_equal(dv, as.Date(double(), origin="1970-01-01")) # origin for R < 4.3.0 + +## default ctor: datetime +dtv <- default_ctor_datetimevector() +expect_true(inherits(dtv, "POSIXct")) +expect_equal(length(dtv), 0L) +expect_equal(dtv, as.POSIXct(double(), origin="1970-01-01")) # origin for R < 4.3.0 diff --git a/inst/tinytest/test_dispatch.R b/inst/tinytest/test_dispatch.R old mode 100644 new mode 100755 diff --git a/inst/tinytest/test_expose_class.R b/inst/tinytest/test_expose_class.R index 5c50a7e60..a0662f998 100644 --- a/inst/tinytest/test_expose_class.R +++ b/inst/tinytest/test_expose_class.R @@ -77,7 +77,7 @@ setwd(path) on.exit( setwd(owd), add=TRUE ) R <- shQuote( file.path( R.home( component = "bin" ), "R" )) system( paste(R, "CMD build", pkg_path) ) -gz_name <- paste0(pkg_name, "_1.0.tar.gz") +gz_name <- paste0(pkg_name, "_0.0.1.tar.gz") expect_true( file.exists(gz_name), info = "can successfully R CMD build the pkg") ## check install + require diff --git a/inst/tinytest/test_global_rostream.R b/inst/tinytest/test_global_rostream.R index 156be58fb..04cd7582d 100644 --- a/inst/tinytest/test_global_rostream.R +++ b/inst/tinytest/test_global_rostream.R @@ -19,7 +19,7 @@ .runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") - +exit_file("For now") library(Rcpp) mkv <- "PKG_CPPFLAGS = -DRCPP_USE_GLOBAL_ROSTREAM" diff --git a/inst/tinytest/test_interface.R b/inst/tinytest/test_interface.R index 22536db58..707571f27 100644 --- a/inst/tinytest/test_interface.R +++ b/inst/tinytest/test_interface.R @@ -81,16 +81,18 @@ expect_equal(result, 0L) ## Now test client package without protected evaluation unlink(user_name, recursive = TRUE) unlink(paste0(user_name, "-tests"), recursive = TRUE) -build_package(user_name, lib_path, config = "#define RCPP_NO_UNWIND_PROTECT") -result <- tools::testInstalledPackage(user_name, lib.loc = lib_path, types = "test") +## no longer supported in code +## build_package(user_name, lib_path, config = "#define RCPP_NO_UNWIND_PROTECT") -if (result) { - log <- file.path(paste0(user_name, "-tests"), "tests.Rout.fail") - cat(">> UNPROTECTED tests.Rout.fail", readLines(log), sep = "\n", file = stderr()) -} +## result <- tools::testInstalledPackage(user_name, lib.loc = lib_path, types = "test") -expect_equal(result, 0L) +## if (result) { +## log <- file.path(paste0(user_name, "-tests"), "tests.Rout.fail") +## cat(">> UNPROTECTED tests.Rout.fail", readLines(log), sep = "\n", file = stderr()) +## } + +## expect_equal(result, 0L) on.exit({ setwd(old_wd) diff --git a/inst/tinytest/test_language.R b/inst/tinytest/test_language.R index 3aa85898b..b7eef0b88 100644 --- a/inst/tinytest/test_language.R +++ b/inst/tinytest/test_language.R @@ -139,3 +139,5 @@ expect_equal( runit_formula_SEXP( "x ~ y + z" ), x ~ y + z, info = "Formula( SEX expect_equal( runit_formula_SEXP( parse( text = "x ~ y + z") ), x ~ y + z, info = "Formula( SEXP = EXPRSXP )" ) expect_equal( runit_formula_SEXP( list( "x ~ y + z") ), x ~ y + z, info = "Formula( SEXP = VECSXP(1 = STRSXP) )" ) expect_equal( runit_formula_SEXP( list( x ~ y + z) ), x ~ y + z, info = "Formula( SEXP = VECSXP(1 = formula) )" ) + +expect_equal( runit_language_modify(sum), c(999, 1), info = "Language objects don't duplicate their arguments" ) diff --git a/inst/tinytest/test_misc.R b/inst/tinytest/test_misc.R index 9fb5f50d9..08df4b5cd 100644 --- a/inst/tinytest/test_misc.R +++ b/inst/tinytest/test_misc.R @@ -168,7 +168,7 @@ expect_equal( testNullableIsUsable(M), M) # test.NullableIsUsableFalse <- function() { expect_true(is.null(testNullableIsUsable(NULL))) -# test.NullableString <- function() { +## test.NullableString <- function() { expect_equal(testNullableString(), "") expect_equal(testNullableString("blah"), "blah") diff --git a/inst/tinytest/test_module.R b/inst/tinytest/test_module.R index 361a801f0..960a33e96 100644 --- a/inst/tinytest/test_module.R +++ b/inst/tinytest/test_module.R @@ -22,11 +22,25 @@ if( ! Rcpp:::capabilities()[["Rcpp modules"]] ) exit_file("Skipping as no Module Rcpp::sourceCpp("cpp/Module.cpp") +# checks the presence of "invisible", added when the function returns void +is_void <- function(call) { + if (length(grep("invisible", deparse(call))) == 0) + return(FALSE) + return(TRUE) +} + # test.Module <- function(){ expect_equal( bar( 2L ), 4L ) expect_equal( foo( 2L, 10.0 ), 20.0 ) expect_equal( hello(), "hello" ) +expect_false(is_void(bar@.Data)) +expect_false(is_void(foo@.Data)) +expect_false(is_void(hello@.Data)) +expect_true(is_void(bla@.Data)) +expect_true(is_void(bla1@.Data)) +expect_true(is_void(bla2@.Data)) + w <- new( ModuleWorld ) expect_equal( w$greet(), "hello" ) w$set( "hello world" ) @@ -38,6 +52,12 @@ expect_equal( w$greet(), "hello world const ref" ) w$clear( ) expect_equal( w$greet(), "" ) +expect_false(is_void(w$greet)) +expect_true(is_void(w$set)) +expect_true(is_void(w$set_ref)) +expect_true(is_void(w$set_const_ref)) +expect_true(is_void(w$clear)) + # test.Module.exposed.class <- function(){ test <- new( ModuleTest, 3.0 ) expect_equal( Test_get_x_const_ref(test), 3.0 ) @@ -45,6 +65,11 @@ expect_equal( Test_get_x_const_pointer(test), 3.0 ) expect_equal( Test_get_x_ref(test), 3.0 ) expect_equal( Test_get_x_pointer(test), 3.0 ) +expect_false(is_void(Test_get_x_const_ref@.Data)) +expect_false(is_void(Test_get_x_const_pointer@.Data)) +expect_false(is_void(Test_get_x_ref@.Data)) +expect_false(is_void(Test_get_x_pointer@.Data)) + expect_equal( attr_Test_get_x_const_ref(test), 3.0 ) expect_equal( attr_Test_get_x_const_pointer(test), 3.0 ) expect_equal( attr_Test_get_x_ref(test), 3.0 ) diff --git a/inst/tinytest/test_rcpp_package_skeleton.R b/inst/tinytest/test_rcpp_package_skeleton.R index b1107c315..6672d231b 100644 --- a/inst/tinytest/test_rcpp_package_skeleton.R +++ b/inst/tinytest/test_rcpp_package_skeleton.R @@ -45,10 +45,10 @@ checkTrue( "foo" %in% list.files(path), "pkg path generated as named" ) ## check the DESCRIPTION DESCRIPTION <- as.list( read.dcf( file.path(pkg_path, "DESCRIPTION") )[1,] ) -checkTrue( DESCRIPTION["Author"] == "Boo-Boo Bear", - "wrote the Author field in DESCRIPTION" ) -checkTrue( DESCRIPTION["Maintainer"] == "Yogi Bear ", - "wrote the Maintainer field in DESCRIPTION") +checkEqual(gsub("\\n", " ", DESCRIPTION["Authors@R"]), # need to neutralise a line break + 'person("Boo-Boo", "Bear", role = c("aut", "cre"), email = "yogibear@yogimail.com")', + "wrote the Authors@R field in DESCRIPTION" ) +checkTrue( DESCRIPTION["Date"] == format(Sys.Date()), "uses current date in DESCRIPTION") checkTrue( DESCRIPTION["License"] == "An Opensource License", "wrote the License field in DESCRIPTION" ) checkTrue( DESCRIPTION["LinkingTo"] == "Rcpp", @@ -86,9 +86,9 @@ owd <- getwd() setwd(path) R <- shQuote( file.path( R.home( component = "bin" ), "R" )) system( paste(R, "CMD build", pkg_path) ) -checkTrue( file.exists("foo_1.0.tar.gz"), "can successfully R CMD build the pkg") +checkTrue( file.exists("foo_0.0.1.tar.gz"), "can successfully R CMD build the pkg") dir.create("templib") -install.packages("foo_1.0.tar.gz", file.path(path, "templib"), repos=NULL, type="source") +install.packages("foo_0.0.1.tar.gz", file.path(path, "templib"), repos=NULL, type="source") require("foo", file.path(path, "templib"), character.only=TRUE) @@ -141,7 +141,7 @@ checkTrue(file.exists( file.path(src_path, "rcpp_module.cpp")), on.exit(unlink(pkg_path, recursive=TRUE)) on.exit( setwd(owd), add=TRUE ) -on.exit( unlink( file.path(path, "foo_1.0.tar.gz") ), add=TRUE) +on.exit( unlink( file.path(path, "foo_0.0.1.tar.gz") ), add=TRUE) on.exit( unlink( file.path(path, "templib"), recursive=TRUE), add=TRUE ) on.exit( unlink(pkg_path, recursive=TRUE), add=TRUE ) on.exit(unlink(pkg_path, recursive=TRUE), add=TRUE) diff --git a/inst/tinytest/test_sourcecpp_errors.R b/inst/tinytest/test_sourcecpp_errors.R new file mode 100644 index 000000000..9391dbc18 --- /dev/null +++ b/inst/tinytest/test_sourcecpp_errors.R @@ -0,0 +1,42 @@ +## Copyright (C) 2026 Dirk Eddelbuettel +## +## 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +## Test 1.1: Invalid File Extension +## Coverage target: R/Attributes.R:58-61 +tmpfile <- tempfile(fileext = ".c") +writeLines("int main() { return 0; }", tmpfile) +expect_error(sourceCpp(tmpfile), "does not have an extension of .cc or .cpp") +unlink(tmpfile) + +## Test 1.2: Filename with Spaces on Windows +## Coverage target: R/Attributes.R:64-68 +if (.Platform$OS.type == "windows") { + tmpfile <- file.path(tempdir(), "test file.cpp") + writeLines("#include ", tmpfile) + expect_error(sourceCpp(tmpfile), "contains spaces") + unlink(tmpfile) +} + +## Test 1.3: windowsDebugDLL on Non-Windows +## Coverage target: R/Attributes.R:70-76 +if (.Platform$OS.type != "windows") { + code <- "// [[Rcpp::export]]\nint test_fn() { return 42; }" + expect_message(sourceCpp(code = code, windowsDebugDLL = TRUE, verbose = TRUE), + "windowsDebugDLL.*ignored") +} diff --git a/inst/tinytest/test_sugar.R b/inst/tinytest/test_sugar.R index 2924e83d0..c6fc58993 100644 --- a/inst/tinytest/test_sugar.R +++ b/inst/tinytest/test_sugar.R @@ -1,5 +1,6 @@ -## Copyright (C) 2010 - 2023 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2010 - 2024 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2025 - 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar ## ## This file is part of Rcpp. ## @@ -19,14 +20,33 @@ if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") Rcpp::sourceCpp("cpp/sugar.cpp") +Rcpp::sourceCpp("cpp/sugar_safe_math.cpp") +Rcpp::sourceCpp("cpp/sugar_safe_math_fallback.cpp") ## There are some (documented, see https://blog.r-project.org/2020/11/02/will-r-work-on-apple-silicon/index.html) ## issues with NA propagation on arm64 / macOS. We not (yet ?) do anything special so we just skip some tests -isArmMacOs <- Sys.info()[["sysname"]] == "Darwin" && Sys.info()[["machine"]] == "arm64" +## This also seems to hit arm64 on Linux (aka 'aarch64' here) +isArm <- Sys.info()[["machine"]] == "arm64" || Sys.info()[["machine"]] == "aarch64" ## Needed for a change in R 3.6.0 reducing a bias in very large samples suppressWarnings(RNGversion("3.5.0")) +# test.sugar.safe_math +expect_equal(safe_add(3, 2), 5) +expect_error(safe_add(.Machine$integer.max, 2), "overflow") +expect_equal(safe_sub(3, 2), 1) +expect_error(safe_sub(-.Machine$integer.max, 2), "overflow") +expect_equal(safe_mul(3, 2), 6) +expect_error(safe_mul(.Machine$integer.max, 2), "overflow") + +expect_equal(safe_add_fallback(3, 2), 5) +expect_error(safe_add_fallback(.Machine$integer.max, 2), "overflow") +expect_equal(safe_sub_fallback(3, 2), 1) +expect_error(safe_sub_fallback(-.Machine$integer.max, 2), "overflow") +expect_equal(safe_mul_fallback(3, 2), 6) +expect_error(safe_mul_fallback(.Machine$integer.max, 2), "overflow") + + # test.sugar.abs <- function( ){ x <- rnorm(10) y <- -10:10 @@ -35,8 +55,8 @@ expect_equal( runit_abs(x,y) , list( abs(x), abs(y) ) ) # test.sugar.all.one.less <- function( ){ expect_true( runit_all_one_less( 1 ) ) expect_true( ! runit_all_one_less( 1:10 ) ) -if (!isArmMacOs) expect_true( is.na( runit_all_one_less( NA ) ) ) -if (!isArmMacOs) expect_true( is.na( runit_all_one_less( c( NA, 1) ) ) ) +if (!isArm) expect_true( is.na( runit_all_one_less( NA ) ) ) +if (!isArm) expect_true( is.na( runit_all_one_less( c( NA, 1) ) ) ) expect_true( ! runit_all_one_less( c( 6, NA) ) ) @@ -45,14 +65,14 @@ expect_true( ! runit_all_one_greater( 1 ) ) expect_true( ! runit_all_one_greater( 1:10 ) ) expect_true( runit_all_one_greater( 6:10 ) ) expect_true( ! runit_all_one_greater( c(NA, 1) ) ) -if (!isArmMacOs) expect_true( is.na( runit_all_one_greater( c(NA, 6) ) ) ) +if (!isArm) expect_true( is.na( runit_all_one_greater( c(NA, 6) ) ) ) # test.sugar.all.one.less.or.equal <- function( ){ expect_true( runit_all_one_less_or_equal( 1 ) ) expect_true( ! runit_all_one_less_or_equal( 1:10 ) ) -if (!isArmMacOs) expect_true( is.na( runit_all_one_less_or_equal( NA ) ) ) -if (!isArmMacOs) expect_true( is.na( runit_all_one_less_or_equal( c( NA, 1) ) ) ) +if (!isArm) expect_true( is.na( runit_all_one_less_or_equal( NA ) ) ) +if (!isArm) expect_true( is.na( runit_all_one_less_or_equal( c( NA, 1) ) ) ) expect_true( ! runit_all_one_less_or_equal( c( 6, NA) ) ) expect_true( runit_all_one_less_or_equal( 5 ) ) @@ -65,7 +85,7 @@ expect_true( ! fx( 1:10 ) ) expect_true( fx( 6:10 ) ) expect_true( fx( 5 ) ) expect_true( ! fx( c(NA, 1) ) ) -if (!isArmMacOs) expect_true( is.na( fx( c(NA, 6) ) ) ) +if (!isArm) expect_true( is.na( fx( c(NA, 6) ) ) ) # test.sugar.all.one.equal <- function( ){ @@ -73,7 +93,7 @@ fx <- runit_all_one_equal expect_true( ! fx( 1 ) ) expect_true( ! fx( 1:2 ) ) expect_true( fx( rep(5,4) ) ) -if (!isArmMacOs) expect_true( is.na( fx( c(5,NA) ) ) ) +if (!isArm) expect_true( is.na( fx( c(5,NA) ) ) ) expect_true(! fx( c(NA, 1) ) ) @@ -82,7 +102,7 @@ fx <- runit_all_not_equal_one expect_true( fx( 1 ) ) expect_true( fx( 1:2 ) ) expect_true( ! fx( 5 ) ) -if (!isArmMacOs) expect_true( is.na( fx( c(NA, 1) ) ) ) +if (!isArm) expect_true( is.na( fx( c(NA, 1) ) ) ) expect_true( ! fx( c(NA, 5) ) ) @@ -208,6 +228,7 @@ expect_true( identical( fx( NA, 1 ), NA ) ) # test.sugar.diff <- function( ){ +expect_error(runit_diff_int(c(1, 2, -.Machine$integer.max)), "overflow") x <- as.integer(round(rnorm(100,1,100))) expect_equal( runit_diff_int(x) , diff(x) ) x <- rnorm( 100 ) @@ -302,15 +323,63 @@ expect_equal( fx( c(1:10) ), fx( c(1:10) ) ) # test.sugar.lapply <- function( ){ fx <- runit_lapply +expect_equal( fx( 1:10 ), as.list((1:10)^2) ) + + +# test.sugar.lapply.rawfun <- function( ){ +fx <- runit_lapply_rawfun +expect_equal( fx( 1:10 ), as.list((1:10)^2) ) + + +# test.sugar.lapply.lambda <- function( ){ +fx <- runit_lapply_lambda +expect_equal( fx( 1:10 ), as.list((1:10)^2) ) + + +# test.sugar.lapply.seq <- function( ){ +fx <- runit_lapply_seq expect_equal( fx( 1:10 ), lapply( 1:10, seq_len ) ) +# test.sugar.mapply2 <- function( ){ +fx <- runit_mapply2 +expect_equal( fx(1:10, 1:10) , 1:10+1:10 ) + + +# test.sugar.mapply2.lambda <- function( ){ +fx <- runit_mapply2_lambda +expect_equal( fx(1:10, 1:10) , 1:10+1:10 ) + + +# test.sugar.mapply3.lambda <- function( ){ +fx <- runit_mapply3_lambda +expect_equal( fx(1:10, 1:10, 1:10) , 1:10+1:10+1:10 ) + + +# test.sugar.mapply2.logical <- function( ){ +fx <- runit_mapply2_logical +expect_true( fx(1:10, 1:10) ) + + +# test.sugar.mapply2.list <- function( ){ +fx <- runit_mapply2_list +expect_equal( fx(1:10, 1:10*2) , mapply(seq, 1:10, 1:10*2) ) + + # test.sugar.minus <- function( ){ +expect_error(runit_minus_ivv(-.Machine$integer.max, 2), "overflow") +expect_error(runit_minus_ivp(-.Machine$integer.max, 2), "overflow") +expect_error(runit_minus_ipv(-.Machine$integer.max, 2), "overflow") fx <- runit_minus expect_equal(fx(1:10) , list( (1:10)-10L, 10L-(1:10), rep(0L,10), (1:10)-10L, 10L-(1:10) )) +# test.sugar.minus.seqlen <- function( ){ +fx <- runit_minus_seqlen +expect_equal( fx(1:10) , list( -9:0, 9:0, rep(0, 10), rep(0, 10), rep(0, 10)) ) + + # test.sugar.any.equal.not <- function( ){ fx <- runit_any_equal_not expect_true( ! fx( 1, 1 ) ) @@ -321,13 +390,16 @@ expect_true( is.na( fx( NA, 1 ) ) ) # test.sugar.plus <- function( ){ +expect_error(runit_plus_ivv(.Machine$integer.max, 2), "overflow") +expect_error(runit_plus_ivp(.Machine$integer.max, 2), "overflow") +expect_error(runit_plus_ipv(.Machine$integer.max, 2), "overflow") fx <- runit_plus expect_equal( fx(1:10) , list( 11:20,11:20,1:10+1:10, 3*(1:10)) ) # test.sugar.plus.seqlen <- function( ){ fx <- runit_plus_seqlen -expect_equal( fx() , list( 11:20,11:20, 1:10+1:10) ) +expect_equal( fx(1:10) , list( 11:20,11:20, 1:10+1:10, 1:10+1:10, 1:10+1:10) ) # test.sugar.plus.all <- function( ){ @@ -380,6 +452,11 @@ fx <- runit_sapply_rawfun expect_equal( fx(1:10) , (1:10)^2 ) +# test.sugar.sapply.lambda <- function( ){ +fx <- runit_sapply_lambda +expect_equal( fx(1:10) , (1:10)^2 ) + + # test.sugar.sapply.square <- function( ){ fx <- runit_sapply_square expect_true( ! fx(1:10) ) @@ -408,12 +485,20 @@ expect_equal(fx( seq(-10, 10, length.out = 51), -25:25 ), # test.sugar.times <- function( ){ +expect_error(runit_times_ivv(.Machine$integer.max, 2), "overflow") +expect_error(runit_times_ivp(.Machine$integer.max, 2), "overflow") +expect_error(runit_times_ipv(.Machine$integer.max, 2), "overflow") fx <- runit_times expect_equal(fx(1:10) , list(10L*(1:10), 10L*(1:10), (1:10)*(1:10), (1:10)*(1:10)*(1:10), c(NA,(2:10)*(2:10)), c(NA,10L*(2:10)), c(NA,10L*(2:10)), rep( NA_integer_, 10L ))) +# test.sugar.times.seqlen <- function( ){ +fx <- runit_times_seqlen +expect_equal( fx(1:10) , list( seq(10, 100, 10), seq(10, 100, 10), 1:10*1:10, 1:10*1:10, 1:10*1:10) ) + + # test.sugar.divides <- function( ){ fx <- runit_divides expect_equal(fx(1:10) , @@ -492,6 +577,13 @@ y <- 1:5 expect_equal( fx(x,y) , outer(x,y,"+") ) +# test.sugar.matrix.outer.lambda <- function( ){ +fx <- runit_outer_lambda +x <- 1:2 +y <- 1:5 +expect_equal( fx(x,y) , outer(x,y,"+") ) + + # test.sugar.matrix.row <- function( ){ fx <- runit_row m <- matrix( 1:16, nc = 4 ) @@ -572,20 +664,38 @@ expect_equal(fx(10:6,5:1), VP = psigamma( 10:6, 5 ))) -# test.sugar.sum <- function(){ -fx <- runit_sum +# test.sugar.sum_nv <- function(){ +fx <- runit_sum_nv x <- rnorm( 10 ) expect_equal( fx(x), sum(x) ) x[4] <- NA expect_equal( fx(x), sum(x) ) -# test.sugar.cumsum <- function(){ -fx <- runit_cumsum -x <- rnorm( 10 ) -expect_equal( fx(x), cumsum(x) ) +# test.sugar.sum_iv <- function() { +expect_error(runit_sum_iv(c(2, .Machine$integer.max)), "overflow") +fx <- runit_sum_iv +x <- as.integer(rpois(10, 5)) +expect_equal(fx(x), sum(x)) x[4] <- NA -expect_equal( fx(x), cumsum(x) ) +expect_equal(fx(x), sum(x)) + + +# test.sugar.cumsum_nv <- function(){ +fx <- runit_cumsum_nv +x <- rnorm(10) +expect_equal(fx(x), cumsum(x)) +x[4] <- NA +expect_equal(fx(x), cumsum(x)) + + +# test.sugar.cumsum_iv <- function() { +expect_error(runit_cumsum_iv(c(2, .Machine$integer.max)), "overflow") +fx <- runit_cumsum_iv +x <- as.integer(rpois(10, 5)) +expect_equal(fx(x), cumsum(x)) +x[4] <- NA +expect_equal(fx(x), cumsum(x)) # test.sugar.asvector <- function(){ @@ -654,6 +764,8 @@ expect_equal(sort(unique(x)), sort(runit_unique_dbl(x)), info = "unique / numeri x <- c(x, NA, NA) expect_equal(sort(unique(x), na.last = TRUE), sort(runit_unique_dbl(x), na.last = TRUE), info = "unique / numeric / with NA") +x <- c(x, -0.0, +0.0) +expect_equal(sort(unique(x)), sort(runit_unique_dbl(x)), info = "unique / numeric / with signed 0s") # test.sort_unique <- function() { set.seed(123) @@ -770,6 +882,7 @@ expect_equal(fx(x), cumprod(x)) # test.sugar.cumprod_iv <- function() { +expect_error(runit_cumprod_iv(c(2, .Machine$integer.max)), "overflow") fx <- runit_cumprod_iv x <- as.integer(rpois(10, 5)) expect_equal(fx(x), cumprod(x)) @@ -1104,6 +1217,11 @@ expect_equal(dbl_col_means(x, TRUE), colMeans(x, TRUE), info = "numeric / colMea ## {row,col}{Sums,Means} integer tests # test.sugar.rowMeans_integer <- function() { +x <- matrix(rep(.Machine$integer.max, 4), 2) + +expect_error(int_row_sums(x), "overflow") +expect_error(int_col_sums(x), "overflow") + x <- matrix(as.integer(rnorm(9) * 1e4), 3) expect_equal(int_row_sums(x), rowSums(x), info = "integer / rowSums / keep NA / clean input") @@ -1216,10 +1334,11 @@ expect_equal(cx_col_sums(x, TRUE), colSums(x, TRUE), info = "complex / colSums / expect_equal(cx_row_means(x), rowMeans(x), info = "complex / rowMeans / keep NA / mixed input") expect_equal(cx_row_means(x, TRUE), rowMeans(x, TRUE), info = "complex / rowMeans / rm NA / mixed input") +expect_equal(cx_row_means(x, TRUE), apply(x, 1, mean, na.rm=TRUE), info = "complex / rowMeans / rm NA / mixed input") expect_equal(cx_col_means(x), colMeans(x), info = "complex / colMeans / keep NA / mixed input") expect_equal(cx_col_means(x, TRUE), colMeans(x, TRUE), info = "complex / colMeans / rm NA / mixed input") - +expect_equal(cx_col_means(x, TRUE), apply(x, 2, mean, na.rm=TRUE), info = "complex / colMeans / rm NA / mixed input") x[] <- NA_complex_ @@ -1566,12 +1685,10 @@ expect_error(strimws(x[1], "invalid"), info = "strimws -- bad `which` argument") ## 21 July 2018 ## min/max # test.sugar.min.max <- function() { -## min(empty) gives NA for integer, Inf for numeric (#844) -expect_true(is.na(intmin(integer(0))), "min(integer(0))") -if (!isArmMacOs) expect_equal(doublemin(numeric(0)), Inf, info = "min(numeric(0))") +expect_error(intmin(integer(0)), "missing argument") +if (!isArm) expect_equal(doublemin(numeric(0)), Inf, info = "min(numeric(0))") -## max(empty_ gives NA for integer, Inf for numeric (#844) -expect_true(is.na(intmax(integer(0))), "max(integer(0))") +expect_error(intmax(integer(0)), "missing argument") expect_equal(doublemax(numeric(0)), -Inf, info = "max(numeric(0))") ## 'normal' values diff --git a/inst/tinytest/test_system.R b/inst/tinytest/test_system.R index 83a99e05f..982a3856c 100644 --- a/inst/tinytest/test_system.R +++ b/inst/tinytest/test_system.R @@ -1,5 +1,5 @@ -## Copyright (C) 2016 - 2019 Dirk Eddelbuettel +## Copyright (C) 2016 - 2025 Dirk Eddelbuettel ## ## This file is part of Rcpp. ## @@ -24,9 +24,9 @@ inc_sys <- tools::file_path_as_absolute( base::system.file("include", package = expect_equal(inc_rcpp, inc_sys, info = "Rcpp.system.file") # test.RcppLd <- function() { -expect_true(Rcpp:::RcppLdPath() == "", info = "RcppLdPath") -expect_true(Rcpp:::RcppLdFlags() == "", info = "RcppLdFlags") -expect_equal(Rcpp:::LdFlags(), NULL, info = "LdFlags") +expect_true(suppressMessages(Rcpp:::RcppLdPath()) == "", info = "RcppLdPath") +expect_true(suppressMessages(Rcpp:::RcppLdFlags()) == "", info = "RcppLdFlags") +expect_equal(suppressMessages(Rcpp:::LdFlags()), NULL, info = "LdFlags") # test.RcppCxx <- function() { expect_true(Rcpp:::canUseCXX0X(), info = "canUseCXX0X") diff --git a/inst/tinytest/test_vector.R b/inst/tinytest/test_vector.R index e8138e24e..f65048c3d 100644 --- a/inst/tinytest/test_vector.R +++ b/inst/tinytest/test_vector.R @@ -1,5 +1,6 @@ -## Copyright (C) 2010 - 2019 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain François +## Copyright (C) 2026 Dirk Eddelbuettel, Romain François and Iñaki Ucar ## ## This file is part of Rcpp. ## @@ -117,7 +118,10 @@ expect_equal( fun(), 0:3, info = "assign(int*, int*)" ) # test.IntegerVector.names.set <- function(){ fun <- integer_names_set -expect_equal(names(fun()), c("foo", "bar"), info = "Vector::names" ) +x <- 1:2 +expect_equal(names(fun(x, c("foo", "bar"))), c("foo", "bar"), info = "Vector::names set" ) +expect_equal(names(fun(x, "foo")), c("foo", NA), info = "Vector::names set shorter" ) +expect_equal(names(fun(x, NULL)), NULL, info = "Vector::names unset" ) # test.IntegerVector.names.get <- function(){ fun <- integer_names_get @@ -702,3 +706,8 @@ expect_true( !CharacterVector_test_equality_crosspolicy("foo", "bar") ) #expect_warning(CharacterVector_test_out_of_bounds_read(character(0), 0)) #expect_warning(CharacterVector_test_out_of_bounds_read(character(1), 1)) + +# https://github.com/RcppCore/Rcpp/issues/1461 +expect_equal(vec_copy(as.numeric(1:10)), as.numeric(1:10)) +expect_equal(vec_copy(numeric(0)), numeric(0)) + diff --git a/inst/tinytest/test_wrap.R b/inst/tinytest/test_wrap.R index cf185222f..d0c0498c2 100644 --- a/inst/tinytest/test_wrap.R +++ b/inst/tinytest/test_wrap.R @@ -132,3 +132,6 @@ expect_equal(sapply( vector_Foo(), function(.) .$get() ), c(2, 3), # test.wrap.custom.class <- function() { expect_equal(test_wrap_custom_class(), 42) + +# test.wrap.string_view <- function() { +expect_equal(test_wrap_string_view(), "test string value") diff --git a/man/Rcpp-deprecated.Rd b/man/Rcpp-deprecated.Rd index b2c8a763e..ddf287bbe 100644 --- a/man/Rcpp-deprecated.Rd +++ b/man/Rcpp-deprecated.Rd @@ -7,9 +7,6 @@ } \details{ \itemize{ - \item \code{\link{loadRcppModules}} calls should now be replaced by - \code{\link{loadModule}} calls, one per Module. - \item \code{\link{LdFlags}} and \code{\link{RcppLdFlags}} are no longer required as no library is provided (or needed) by Rcpp (as it was up until release 0.10.1). diff --git a/man/Rcpp.package.skeleton.Rd b/man/Rcpp.package.skeleton.Rd index c3dfdbc48..49d3152af 100644 --- a/man/Rcpp.package.skeleton.Rd +++ b/man/Rcpp.package.skeleton.Rd @@ -4,20 +4,20 @@ Create a skeleton for a new package depending on Rcpp } \description{ - \code{Rcpp.package.skeleton} automates the creation of - a new source package that intends to use features of Rcpp. - + \code{Rcpp.package.skeleton} automates the creation of + a new source package that intends to use features of Rcpp. + It is based on the \link[utils]{package.skeleton} function which it executes first. } \usage{ -Rcpp.package.skeleton(name = "anRpackage", list = character(), - environment = .GlobalEnv, path = ".", force = FALSE, +Rcpp.package.skeleton(name = "anRpackage", list = character(), + environment = .GlobalEnv, path = ".", force = FALSE, code_files = character(), cpp_files = character(), - example_code = TRUE, attributes = TRUE, module = FALSE, - author = "Your Name", - maintainer = if(missing( author)) "Your Name" else author, - email = "your@email.com", + example_code = TRUE, attributes = TRUE, module = FALSE, + author = "Your Name", + maintainer = if(missing( author)) "Your Name" else author, + email = "your@email.com", githubuser = NA_character_, license = "GPL (>= 2)" ) } @@ -35,42 +35,43 @@ Rcpp.package.skeleton(name = "anRpackage", list = character(), \item{author}{Author of the package.} \item{maintainer}{Maintainer of the package.} \item{email}{Email of the package maintainer.} + \item{githubuser}{GitHub username for URL and BugReports, if present.} \item{license}{License of the package.} } \details{ - In addition to \link[utils]{package.skeleton} : - - The \samp{DESCRIPTION} file gains an Imports line requesting that + In addition to \link[utils]{package.skeleton} : + + The \samp{DESCRIPTION} file gains an Imports line requesting that the package depends on Rcpp and a LinkingTo line so that the package finds Rcpp header files. - + The \samp{NAMESPACE} gains a \code{useDynLib} directive as well as an \code{importFrom(Rcpp, evalCpp} to ensure instantiation of Rcpp. - - The \samp{src} directory is created if it does not exists. - + + The \samp{src} directory is created if it does not exists. + If \code{cpp_files} are provided then they will be copied to the \samp{src} directory. - - If the \code{example_code} argument is set to \code{TRUE}, + + If the \code{example_code} argument is set to \code{TRUE}, example files \samp{rcpp_hello_world.h} and \samp{rcpp_hello_world.cpp} - are also created in the \samp{src}. An R file \samp{rcpp_hello_world.R} is + are also created in the \samp{src}. An R file \samp{rcpp_hello_world.R} is expanded in the \samp{R} directory, the \code{rcpp_hello_world} function defined in this files makes use of the C++ function \samp{rcpp_hello_world} - defined in the C++ file. These files are given as an example and should + defined in the C++ file. These files are given as an example and should eventually by removed from the generated package. - + If the \code{attributes} argument is \code{TRUE}, then rather than generate the example files as described above, a single \samp{rcpp_hello_world.cpp} - file is created in the \samp{src} directory and it's attributes are - compiled using the \code{\link{compileAttributes}} function. This leads to + file is created in the \samp{src} directory and it's attributes are + compiled using the \code{\link{compileAttributes}} function. This leads to the files \samp{RcppExports.R} and \samp{RcppExports.cpp} being generated. - They are automatically regenerated from \emph{scratch} each time - \code{\link{compileAttributes}} is called. Therefore, one should + They are automatically regenerated from \emph{scratch} each time + \code{\link{compileAttributes}} is called. Therefore, one should \strong{not} modify by hand either of the \samp{RcppExports} files. - - If the \code{module} argument is \code{TRUE}, a sample Rcpp module will - be generated as well. + + If the \code{module} argument is \code{TRUE}, a sample Rcpp module will + be generated as well. } \value{ Nothing, used for its side effects @@ -105,4 +106,3 @@ vignette( "Rcpp-modules" ) } } \keyword{ programming } - diff --git a/man/RcppUnitTests.Rd b/man/RcppUnitTests.Rd deleted file mode 100644 index d1f513e42..000000000 --- a/man/RcppUnitTests.Rd +++ /dev/null @@ -1,28 +0,0 @@ -\name{RcppUnitTests} -\alias{RcppUnitTests} - -\title{Rcpp : unit tests results} -\description{ -Unit tests results for package Rcpp. - -Unit tests are run automatically at build time and reports are included in the -\samp{doc} directory as html or text. -} - -\seealso{ -\ifelse{latex}{}{\ifelse{html}{\url{../doc/unitTests-results/Rcpp-unitTests.html}: html formatted unit test report}{\samp{../doc/unitTests-results/Rcpp-unitTests.html}: html formatted unit test report}} -} - -\examples{ -# unit tests are in the unitTests directory of the package -list.files( system.file("unitTests", package = "Rcpp" ), - pattern = "^runit", full = TRUE ) - -# trigger the unit tests preparation, follow printed instructions -# on how to run them -\dontrun{ -source( system.file("unitTests", "runTests.R", package = "Rcpp" ) ) -} -} - -\keyword{programming} diff --git a/man/asisWeave.Rd b/man/asisWeave.Rd new file mode 100644 index 000000000..1ce5139dd --- /dev/null +++ b/man/asisWeave.Rd @@ -0,0 +1,48 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/asis.R +\name{asisWeave} +\alias{asisWeave} +\alias{asisTangle} +\title{Process pdf vignettes \sQuote{asis}} +\usage{ +asisWeave(file, ...) + +asisTangle(file, ..., pattern = "(|[.][^.]*)[.]asis$") +} +\arguments{ +\item{file}{character Filename to be processed} + +\item{...}{dots Currently ignored} + +\item{pattern}{character A regular expression describing the filename pattern} +} +\value{ +The respective filename is returned, invisibly +} +\description{ +Simple \sQuote{asis} Vignette Processor +} +\details{ +To pass pre-made pdf vignettes through \dQuote{as is}, a simple vignette +process is added. It is derived from the more feature-complete one in the \pkg{R.rsp} +package. To use it, add files named like the pdf file plus an appended \code{.asis} +with the vignette metainformation and register the vignette processor, see the examples. +} +\examples{ +# To register this vignette engine in another package, add +# \code{VignetteBuilder: Rcpp} as well as \code{Suggests: Rcpp} to \code{DESCRIPTION} +# which uses the registration this package provides via +\dontrun{tools::vignetteEngine("asis", package = pkgname, pattern = "[.](pdf|html)[.]asis$", + weave = asisWeave, tangle = asisTangle)} + +# Use a .asis file as in the Rcpp package, for example Rcpp-FAQ.pdf.asis has these lines: +# \%\VignetteIndexEntry{Rcpp-FAQ} +# \%\VignetteKeywords{Rcpp, FAQ, R, Cpp} +# \%\VignettePackage{Rcpp} +# \%\VignetteEncoding{UTF-8} +# \%\VignetteEngine{Rcpp::asis} +} +\author{ +Henrik Bengtsson for the original versions in package \pkg{R.rsp}, +Dirk Eddelbuettel for the shortened ones used here +} diff --git a/man/compilerCheck.Rd b/man/compilerCheck.Rd deleted file mode 100644 index 954ac883b..000000000 --- a/man/compilerCheck.Rd +++ /dev/null @@ -1,31 +0,0 @@ -% Generated by roxygen2: do not edit by hand -% Please edit documentation in R/compilerCheck.R -\name{compilerCheck} -\alias{compilerCheck} -\title{Check for Minimal (g++) Compiler Version} -\usage{ -compilerCheck(minVersion = package_version("4.6.0")) -} -\arguments{ -\item{minVersion}{An object of type \code{package_version}, with a default -of version 4.6.0} -} -\value{ -A boolean value is returned, indicating if the minimal version is - being met -} -\description{ -Helper function to establish minimal compiler versions, currently limited -only to \code{g++} which (particularly for older RHEL/CentOS releases) is -too far behind current C++11 standards required for some packages. -} -\details{ -This function looks up \code{g++} (as well as optional values in the -\code{CXX} and \code{CXX1X} environment variables) in the \code{PATH}. For -all values found, the output of \code{g++ -v} is analyzed for the version -string, which is then compared to the given minimal version. -} -\author{ -Dirk Eddelbuettel -} - diff --git a/man/evalCpp.Rd b/man/evalCpp.Rd index d3285f6ad..49ce082e7 100644 --- a/man/evalCpp.Rd +++ b/man/evalCpp.Rd @@ -5,16 +5,16 @@ Evaluate a C++ Expression } \description{ -Evaluates a C++ expression. This creates a C++ function using -\code{\link{cppFunction}} and calls it to get the result. +Evaluates a C++ expression. This creates a C++ function using +\code{\link{cppFunction}} and calls it to get the result. } \usage{ -evalCpp(code, depends = character(), plugins = character(), includes = character(), +evalCpp(code, depends = character(), plugins = character(), includes = character(), rebuild = FALSE, cacheDir = getOption("rcpp.cache.dir", tempdir()), showOutput = verbose, verbose = getOption("verbose")) -areMacrosDefined(names, depends = character(), includes = character(), - rebuild = FALSE, showOutput = verbose, +areMacrosDefined(names, depends = character(), includes = character(), + rebuild = FALSE, showOutput = verbose, verbose = getOption("verbose")) } \arguments{ @@ -47,10 +47,10 @@ see \code{\link{cppFunction}} } } \note{ - The result type of the C++ expression must be compatible with \code{Rcpp::wrap}. + The result type of the C++ expression must be compatible with \code{Rcpp::wrap}. } \value{ - The result of the evaluated C++ expression. + The result of the evaluated C++ expression. } \seealso{ \code{\link{sourceCpp}}, \code{\link{cppFunction}} @@ -58,10 +58,11 @@ see \code{\link{cppFunction}} \examples{ \dontrun{ -evalCpp( "__cplusplus" ) -evalCpp( "std::numeric_limits::max()" ) - -areMacrosDefined( c("__cplusplus", "HAS_TR1" ) ) +evalCpp("__cplusplus") +evalCpp("std::numeric_limits::max()") + +# areMacrosDefined is no longer exported but accessible via ':::' +Rcpp:::areMacrosDefined(c("__cplusplus", "RCPP_VERSION")) } } diff --git a/man/loadModule.Rd b/man/loadModule.Rd index 03102946d..c45cdb148 100644 --- a/man/loadModule.Rd +++ b/man/loadModule.Rd @@ -80,9 +80,6 @@ John Chambers } \seealso{ \code{\link{setRcppClass}()} to avoid the explicit call. - -\code{\link{loadRcppModules}()} for a (deprecated) shotgun procedure to load all -modules. } \examples{ \dontrun{ diff --git a/man/loadRcppModules-deprecated.Rd b/man/loadRcppModules-deprecated.Rd deleted file mode 100644 index 167efea9e..000000000 --- a/man/loadRcppModules-deprecated.Rd +++ /dev/null @@ -1,26 +0,0 @@ -\name{loadRcppModules-deprecated} -\alias{loadRcppModules} -\title{ - Loads Rcpp modules on package startup -} -\description{ - \emph{Note:} As of release 0.12.5, this function is deprecated; - \code{\link{loadModule}} should be used instead. - - Function to simplify loading Rcpp modules contained in a package. - This function must be called from the \code{.onLoad} function of a package. - It uses the \code{RcppModules} field of the package \code{DESCRIPTION} file - to query the names of the modules that the package should export, loads each module, - and \code{\link{populate}} each module into the package NAMESPACE. -} -\usage{ - loadRcppModules(direct=TRUE) -} -\arguments{ - \item{direct}{if \code{TRUE} the content of the module is exposed in the - namespace. Otherwise, the module is exposed. } -} -\seealso{ - \code{\link{populate}}, \code{\link{loadModule}} -} -\keyword{interface} diff --git a/src/api.cpp b/src/api.cpp index aaf29ef6d..723a90ccc 100644 --- a/src/api.cpp +++ b/src/api.cpp @@ -3,7 +3,7 @@ // api.cpp: Rcpp R/C++ interface class library -- Rcpp api // // Copyright (C) 2012 - 2020 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2021 - 2023 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +// Copyright (C) 2021 - 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -28,7 +28,6 @@ using namespace Rcpp; #include "internal.h" -#include #ifdef RCPP_HAS_DEMANGLING #include @@ -171,32 +170,12 @@ SEXP as_character_externalptr(SEXP xp) { SEXP rcpp_capabilities() { Shield cap(Rf_allocVector(LGLSXP, 13)); Shield names(Rf_allocVector(STRSXP, 13)); - #ifdef HAS_VARIADIC_TEMPLATES - LOGICAL(cap)[0] = TRUE; - #else - LOGICAL(cap)[0] = FALSE; - #endif - #ifdef HAS_CXX0X_INITIALIZER_LIST - LOGICAL(cap)[1] = TRUE; - #else - LOGICAL(cap)[1] = FALSE; - #endif - /* exceptions are always supported */ - LOGICAL(cap)[2] = TRUE; - - #ifdef HAS_TR1_UNORDERED_MAP - LOGICAL(cap)[3] = TRUE; - #else - LOGICAL(cap)[3] = FALSE; - #endif - - #ifdef HAS_TR1_UNORDERED_SET - LOGICAL(cap)[4] = TRUE; - #else - LOGICAL(cap)[4] = FALSE; - #endif - - LOGICAL(cap)[5] = TRUE; + LOGICAL(cap)[0] = TRUE; // HAS_VARIADIC_TEMPLATES + LOGICAL(cap)[1] = TRUE; // HAS_CXX0X_INITIALIZER_LIST + LOGICAL(cap)[2] = TRUE; /* exceptions are always supported */ + LOGICAL(cap)[3] = TRUE; // HAS_TR1_UNORDERED_MAP + LOGICAL(cap)[4] = TRUE; // HAS_TR1_UNORDERED_SET + LOGICAL(cap)[5] = TRUE; // Modules (TODO respect header choice ?) #ifdef RCPP_HAS_DEMANGLING LOGICAL(cap)[6] = TRUE; @@ -204,31 +183,11 @@ SEXP rcpp_capabilities() { LOGICAL(cap)[6] = FALSE; #endif - LOGICAL(cap)[7] = FALSE; - - #ifdef RCPP_HAS_LONG_LONG_TYPES - LOGICAL(cap)[8] = TRUE; - #else - LOGICAL(cap)[8] = FALSE; - #endif - - #ifdef HAS_CXX0X_UNORDERED_MAP - LOGICAL(cap)[9] = TRUE; - #else - LOGICAL(cap)[9] = FALSE; - #endif - - #ifdef HAS_CXX0X_UNORDERED_SET - LOGICAL(cap)[10] = TRUE; - #else - LOGICAL(cap)[10] = FALSE; - #endif - - #ifdef RCPP_USING_CXX11 - LOGICAL(cap)[11] = TRUE; - #else - LOGICAL(cap)[11] = FALSE; - #endif + LOGICAL(cap)[7] = FALSE; // Classic API + LOGICAL(cap)[8] = TRUE; // RCPP_HAS_LONG_LONG_TYPES + LOGICAL(cap)[9] = TRUE; // HAS_CXX0X_UNORDERED_MAP + LOGICAL(cap)[10] = TRUE; // HAS_CXX0X_UNORDERED_SET + LOGICAL(cap)[11] = TRUE; // RCPP_USING_CXX11 #ifdef RCPP_NEW_DATE_DATETIME_VECTORS LOGICAL(cap)[12] = TRUE; @@ -257,24 +216,15 @@ SEXP rcpp_capabilities() { // [[Rcpp::internal]] SEXP rcpp_can_use_cxx0x() { // #nocov start - #if defined(HAS_VARIADIC_TEMPLATES) || defined(RCPP_USING_CXX11) - return Rf_ScalarLogical(TRUE); - #else - return Rf_ScalarLogical(FALSE); - #endif + return Rf_ScalarLogical(TRUE); } // [[Rcpp::internal]] SEXP rcpp_can_use_cxx11() { - #if defined(RCPP_USING_CXX11) - return Rf_ScalarLogical(TRUE); - #else - return Rf_ScalarLogical(FALSE); - #endif + return Rf_ScalarLogical(TRUE); } - // [[Rcpp::register]] SEXP stack_trace(const char* file, int line) { return R_NilValue; diff --git a/src/attributes.cpp b/src/attributes.cpp index 4dfbdbfeb..c98110050 100644 --- a/src/attributes.cpp +++ b/src/attributes.cpp @@ -1,7 +1,7 @@ // attributes.cpp: Rcpp R/C++ interface class library -- Rcpp attributes // // Copyright (C) 2012 - 2020 JJ Allaire, Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2021 - 2023 JJ Allaire, Dirk Eddelbuettel, Romain Francois, Iñaki Ucar and Travers Ching +// Copyright (C) 2021 - 2026 JJ Allaire, Dirk Eddelbuettel, Romain Francois, Iñaki Ucar and Travers Ching // // This file is part of Rcpp. // @@ -357,12 +357,12 @@ namespace attributes { // check for explicit name parameter if (hasParameter(kExportName)) { - return paramNamed(kExportName).value(); // #nocov + return paramNamed(kExportName).value(); } // otherwise un-named parameter in the first slot else if (!params().empty() && params()[0].value().empty()) { - return params()[0].name(); // #nocov + return params()[0].name(); } // otherwise the actual function name { @@ -370,17 +370,17 @@ namespace attributes { } } - std::string exportedCppName() const { // #nocov start + std::string exportedCppName() const { std::string name = exportedName(); std::replace(name.begin(), name.end(), '.', '_'); return name; - } // #nocov end + } bool rng() const { Param rngParam = paramNamed(kExportRng); if (!rngParam.empty()) - return rngParam.value() == kParamValueTrue || // #nocov - rngParam.value() == kParamValueTRUE; // #nocov + return rngParam.value() == kParamValueTrue || + rngParam.value() == kParamValueTRUE; else return true; } @@ -388,8 +388,8 @@ namespace attributes { bool invisible() const { Param invisibleParam = paramNamed(kExportInvisible); if (!invisibleParam.empty()) - return invisibleParam.value() == kParamValueTrue || // #nocov - invisibleParam.value() == kParamValueTRUE; // #nocov + return invisibleParam.value() == kParamValueTrue || + invisibleParam.value() == kParamValueTRUE; else return false; } @@ -401,19 +401,11 @@ namespace attributes { std::string sig = sigParam.value(); trimWhitespace(&sig); if (sig.empty()) return sig; -#if __cplusplus < 201103L - if (sig[sig.size() - 1] == '}') -#else if (sig.back() == '}') -#endif sig = sig.substr(0, sig.size()-1); // check sig.empty again since we deleted an element if (sig.empty()) return sig; -#if __cplusplus < 201103L - if (sig[0] == '{') -#else if (sig.front() == '{') -#endif sig.erase(0,1); return sig; } @@ -2493,8 +2485,8 @@ namespace attributes { if(attribute.hasParameter(kExportSignature)) { args = attribute.customRSignature(); if(!checkRSignature(function, args)) { - std::string rsig_err_msg = "Missing args in " + args; - throw Rcpp::exception(rsig_err_msg.c_str()); + std::string rsig_err_msg = "Missing args in " + args; // #nocov + throw Rcpp::exception(rsig_err_msg.c_str()); // #nocov } } // determine the function name @@ -2961,7 +2953,8 @@ namespace attributes { << " if (rcpp_isError_gen) {" << std::endl << " SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen);" << std::endl << " UNPROTECT(1);" << std::endl - << " Rf_error(\"%s\", CHAR(rcpp_msgSEXP_gen));" << std::endl + // Parentheses to prevent masking + << " (Rf_error)(\"%s\", CHAR(rcpp_msgSEXP_gen));" << std::endl << " }" << std::endl << " UNPROTECT(1);" << std::endl << " return rcpp_result_gen;" << std::endl @@ -3279,7 +3272,7 @@ namespace { // copy the source file to the build dir Rcpp::Function filecopy = Rcpp::Environment::base_env()["file.copy"]; - filecopy(cppSourcePath_, generatedCppSourcePath(), true); + filecopy(cppSourcePath_, generatedCppSourcePath(), true, Rcpp::_["copy.mode"] = false); // parse attributes SourceFileAttributesParser sourceAttributes(cppSourcePath_, "", true); diff --git a/src/barrier.cpp b/src/barrier.cpp index c4e417920..aa0febb68 100644 --- a/src/barrier.cpp +++ b/src/barrier.cpp @@ -2,7 +2,7 @@ // barrier.cpp: Rcpp R/C++ interface class library -- write barrier // // Copyright (C) 2010 - 2020 Dirk Eddelbuettel and Romain Francois -// Copyright (C) 2021 - 2022 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar +// Copyright (C) 2021 - 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -76,7 +76,8 @@ SEXP* get_vector_ptr(SEXP x) { // [[Rcpp::register]] void* dataptr(SEXP x) { - return DATAPTR(x); + // DATAPTR_RO was introduced with R 3.5.0 + return const_cast(DATAPTR_RO(x)); } // [[Rcpp::register]] @@ -102,13 +103,13 @@ void Rcpp_precious_init() { R_PreserveObject(Rcpp_precious); // and protect } // [[Rcpp::register]] -void Rcpp_precious_teardown() { +void Rcpp_precious_teardown() { // #nocov start R_ReleaseObject(Rcpp_precious); // release resource -} +} // #nocov end // [[Rcpp::register]] SEXP Rcpp_precious_preserve(SEXP object) { if (object == R_NilValue) { - return R_NilValue; + return R_NilValue; // #nocov } PROTECT(object); SEXP cell = PROTECT(CONS(Rcpp_precious, CDR(Rcpp_precious))); @@ -144,7 +145,11 @@ SEXP get_rcpp_cache() { Rcpp::Shield call(Rf_lang2(getNamespaceSym, RcppString)); Rcpp::Shield RCPP(Rf_eval(call, R_GlobalEnv)); +#if R_VERSION < R_Version(4,5,0) Rcpp_cache = Rf_findVarInFrame(RCPP, Rf_install(".rcpp_cache")); +#else + Rcpp_cache = R_getVar(Rf_install(".rcpp_cache"), RCPP, TRUE); +#endif Rcpp_cache_know = true; } return Rcpp_cache; diff --git a/tests/tinytest.R b/tests/tinytest.R index 29e82d1be..61cc2b8a7 100644 --- a/tests/tinytest.R +++ b/tests/tinytest.R @@ -1,21 +1,26 @@ if (requireNamespace("tinytest", quietly=TRUE)) { - ## Set a seed to make the test deterministic - set.seed(42) - - ## R makes us do this (but tinytest now sets it too) - Sys.setenv("R_TESTS"="") + ## if OMP_THREAD_LIMIT is set, and its value is 2, we have a good + ## idea of where we are and we likely do not want to run all tests + if (Sys.getenv("OMP_THREAD_LIMIT", unset="") == "2") { # set and 2 + if (Sys.getenv("RunAllRcppTests", "") != "") { # if unset + Sys.setenv("RunAllRcppTests"="no") + } + if (Sys.getenv("RunVerboseRcppTests", "") != "") { # if unset + Sys.setenv("RunVerboseRcppTests"="no") + } + } ## Force tests to be executed if in dev release which we define as ## having a sub-release, eg 0.9.15.5 is one whereas 0.9.16 is not - if (length(strsplit(packageDescription("Rcpp")$Version, "\\.")[[1]]) > 3) { # dev rel, and + if (length(strsplit(format(packageVersion("Rcpp")), "\\.")[[1]]) > 3) { # dev rel, and if (Sys.getenv("RunAllRcppTests") != "no") { # if env.var not yet set - message("Setting \"RunAllRcppTests\"=\"yes\" for development release\n") + message("Setting \"RunAllRcppTests\"=\"yes\" for development release") Sys.setenv("RunAllRcppTests"="yes") } if (Sys.getenv("RunVerboseRcppTests") != "no") { # if env.var not yet set - message("Setting \"RunVerboseRcppTests\"=\"yes\" for development release\n") + message("Setting \"RunVerboseRcppTests\"=\"yes\" for development release") Sys.setenv("RunVerboseRcppTests"="yes") } } diff --git a/vignettes/.gitignore b/vignettes/.gitignore index 1b8151441..8fd6643ff 100644 --- a/vignettes/.gitignore +++ b/vignettes/.gitignore @@ -8,3 +8,6 @@ Rcpp-*.tex unitTests-results/ rmd/figures/bootstrap.pdf rmd/OLDbackup +rmd/*_cache +rmd/*.pdf +rmd/*.cls diff --git a/vignettes/Rcpp-FAQ.Rnw b/vignettes/Rcpp-FAQ.Rnw deleted file mode 100644 index d924ed650..000000000 --- a/vignettes/Rcpp-FAQ.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-FAQ} -%\VignetteKeywords{Rcpp, FAQ, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-FAQ.pdf} -\end{document} diff --git a/vignettes/Rcpp-FAQ.pdf b/vignettes/Rcpp-FAQ.pdf index 03298f376..c2745605c 100644 Binary files a/vignettes/Rcpp-FAQ.pdf and b/vignettes/Rcpp-FAQ.pdf differ diff --git a/vignettes/Rcpp-FAQ.pdf.asis b/vignettes/Rcpp-FAQ.pdf.asis new file mode 100644 index 000000000..0e49d5ef2 --- /dev/null +++ b/vignettes/Rcpp-FAQ.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-FAQ} +%\VignetteKeywords{Rcpp, FAQ, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-attributes.Rnw b/vignettes/Rcpp-attributes.Rnw deleted file mode 100644 index e06336e19..000000000 --- a/vignettes/Rcpp-attributes.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-attributes} -%\VignetteKeywords{Rcpp, attributes, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-attributes.pdf} -\end{document} diff --git a/vignettes/Rcpp-attributes.pdf b/vignettes/Rcpp-attributes.pdf index 5f494bb2b..7eca2b952 100644 Binary files a/vignettes/Rcpp-attributes.pdf and b/vignettes/Rcpp-attributes.pdf differ diff --git a/vignettes/Rcpp-attributes.pdf.asis b/vignettes/Rcpp-attributes.pdf.asis new file mode 100644 index 000000000..24863272e --- /dev/null +++ b/vignettes/Rcpp-attributes.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-attributes} +%\VignetteKeywords{Rcpp, attributes, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-extending.Rnw b/vignettes/Rcpp-extending.Rnw deleted file mode 100644 index d4a848384..000000000 --- a/vignettes/Rcpp-extending.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-extending} -%\VignetteKeywords{Rcpp, extending, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-extending.pdf} -\end{document} diff --git a/vignettes/Rcpp-extending.pdf b/vignettes/Rcpp-extending.pdf index 563ed2954..1c85d3175 100644 Binary files a/vignettes/Rcpp-extending.pdf and b/vignettes/Rcpp-extending.pdf differ diff --git a/vignettes/Rcpp-extending.pdf.asis b/vignettes/Rcpp-extending.pdf.asis new file mode 100644 index 000000000..28f9b0836 --- /dev/null +++ b/vignettes/Rcpp-extending.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-extending} +%\VignetteKeywords{Rcpp, extending, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-introduction.Rnw b/vignettes/Rcpp-introduction.Rnw deleted file mode 100644 index d0c6a910b..000000000 --- a/vignettes/Rcpp-introduction.Rnw +++ /dev/null @@ -1,11 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-introduction} -%\VignetteKeywords{Rcpp, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-introduction.pdf} -\end{document} - diff --git a/vignettes/Rcpp-introduction.pdf b/vignettes/Rcpp-introduction.pdf index efb1d489e..268930ea9 100644 Binary files a/vignettes/Rcpp-introduction.pdf and b/vignettes/Rcpp-introduction.pdf differ diff --git a/vignettes/Rcpp-introduction.pdf.asis b/vignettes/Rcpp-introduction.pdf.asis new file mode 100644 index 000000000..9cad6f0b7 --- /dev/null +++ b/vignettes/Rcpp-introduction.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-introduction} +%\VignetteKeywords{Rcpp, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-jss-2011.pdf b/vignettes/Rcpp-jss-2011.pdf index a5ea7b151..eb0d3b057 100644 Binary files a/vignettes/Rcpp-jss-2011.pdf and b/vignettes/Rcpp-jss-2011.pdf differ diff --git a/vignettes/Rcpp-jss-2011.Rnw b/vignettes/Rcpp-jss-2011.pdf.asis similarity index 52% rename from vignettes/Rcpp-jss-2011.Rnw rename to vignettes/Rcpp-jss-2011.pdf.asis index 936b42b9e..d55537828 100644 --- a/vignettes/Rcpp-jss-2011.Rnw +++ b/vignettes/Rcpp-jss-2011.pdf.asis @@ -1,11 +1,5 @@ -\documentclass{article} -\usepackage{pdfpages} %\VignetteIndexEntry{Rcpp-JSS-2011} %\VignetteKeywords{Rcpp, foreign function interface, .Call, C++, R} %\VignettePackage{Rcpp} %\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-jss-2011.pdf} -\end{document} - +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-libraries.Rnw b/vignettes/Rcpp-libraries.Rnw deleted file mode 100644 index 822b0d451..000000000 --- a/vignettes/Rcpp-libraries.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-libraries} -%\VignetteKeywords{Rcpp, Package, Library} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-libraries.pdf} -\end{document} diff --git a/vignettes/Rcpp-libraries.pdf b/vignettes/Rcpp-libraries.pdf index 1971ecfa5..2794e2af6 100644 Binary files a/vignettes/Rcpp-libraries.pdf and b/vignettes/Rcpp-libraries.pdf differ diff --git a/vignettes/Rcpp-libraries.pdf.asis b/vignettes/Rcpp-libraries.pdf.asis new file mode 100644 index 000000000..406c437d5 --- /dev/null +++ b/vignettes/Rcpp-libraries.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-libraries} +%\VignetteKeywords{Rcpp, Package, Library} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-modules.Rnw b/vignettes/Rcpp-modules.Rnw deleted file mode 100644 index 08656fcb6..000000000 --- a/vignettes/Rcpp-modules.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-modules} -%\VignetteKeywords{Rcpp, modules, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-modules.pdf} -\end{document} diff --git a/vignettes/Rcpp-modules.pdf b/vignettes/Rcpp-modules.pdf index 81a679e70..62b1c704e 100644 Binary files a/vignettes/Rcpp-modules.pdf and b/vignettes/Rcpp-modules.pdf differ diff --git a/vignettes/Rcpp-modules.pdf.asis b/vignettes/Rcpp-modules.pdf.asis new file mode 100644 index 000000000..36d004d54 --- /dev/null +++ b/vignettes/Rcpp-modules.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-modules} +%\VignetteKeywords{Rcpp, modules, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-package.Rnw b/vignettes/Rcpp-package.Rnw deleted file mode 100644 index 732f2b38f..000000000 --- a/vignettes/Rcpp-package.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-package} -%\VignetteKeywords{Rcpp, package, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-package.pdf} -\end{document} diff --git a/vignettes/Rcpp-package.pdf b/vignettes/Rcpp-package.pdf index 159d9e40b..aa2cf4e37 100644 Binary files a/vignettes/Rcpp-package.pdf and b/vignettes/Rcpp-package.pdf differ diff --git a/vignettes/Rcpp-package.pdf.asis b/vignettes/Rcpp-package.pdf.asis new file mode 100644 index 000000000..ba64c4df5 --- /dev/null +++ b/vignettes/Rcpp-package.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-package} +%\VignetteKeywords{Rcpp, package, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-quickref.Rnw b/vignettes/Rcpp-quickref.Rnw deleted file mode 100644 index 838f2b4be..000000000 --- a/vignettes/Rcpp-quickref.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-quickref} -%\VignetteKeywords{Rcpp, quickref, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-quickref.pdf} -\end{document} diff --git a/vignettes/Rcpp-quickref.pdf b/vignettes/Rcpp-quickref.pdf index b7c150ec5..ddca8d948 100644 Binary files a/vignettes/Rcpp-quickref.pdf and b/vignettes/Rcpp-quickref.pdf differ diff --git a/vignettes/Rcpp-quickref.pdf.asis b/vignettes/Rcpp-quickref.pdf.asis new file mode 100644 index 000000000..1edafab99 --- /dev/null +++ b/vignettes/Rcpp-quickref.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-quickref} +%\VignetteKeywords{Rcpp, quickref, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-sugar.Rnw b/vignettes/Rcpp-sugar.Rnw deleted file mode 100644 index e4ab3b13c..000000000 --- a/vignettes/Rcpp-sugar.Rnw +++ /dev/null @@ -1,10 +0,0 @@ -\documentclass{article} -\usepackage{pdfpages} -%\VignetteIndexEntry{Rcpp-sugar} -%\VignetteKeywords{Rcpp, sugar, R, Cpp} -%\VignettePackage{Rcpp} -%\VignetteEncoding{UTF-8} - -\begin{document} -\includepdf[pages=-, fitpaper=true]{pdf/Rcpp-sugar.pdf} -\end{document} diff --git a/vignettes/Rcpp-sugar.pdf b/vignettes/Rcpp-sugar.pdf index f3f9a06fa..6f61a6d53 100644 Binary files a/vignettes/Rcpp-sugar.pdf and b/vignettes/Rcpp-sugar.pdf differ diff --git a/vignettes/Rcpp-sugar.pdf.asis b/vignettes/Rcpp-sugar.pdf.asis new file mode 100644 index 000000000..64c5c3871 --- /dev/null +++ b/vignettes/Rcpp-sugar.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-sugar} +%\VignetteKeywords{Rcpp, sugar, R, Cpp} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/pdf/Rcpp-FAQ.pdf b/vignettes/pdf/Rcpp-FAQ.pdf deleted file mode 100644 index e4159dd55..000000000 Binary files a/vignettes/pdf/Rcpp-FAQ.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-attributes.pdf b/vignettes/pdf/Rcpp-attributes.pdf deleted file mode 100644 index d7eebb855..000000000 Binary files a/vignettes/pdf/Rcpp-attributes.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-extending.pdf b/vignettes/pdf/Rcpp-extending.pdf deleted file mode 100644 index df1fc559f..000000000 Binary files a/vignettes/pdf/Rcpp-extending.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-introduction.pdf b/vignettes/pdf/Rcpp-introduction.pdf deleted file mode 100644 index 7ec1a2597..000000000 Binary files a/vignettes/pdf/Rcpp-introduction.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-jss-2011.pdf b/vignettes/pdf/Rcpp-jss-2011.pdf deleted file mode 100644 index 1478830d4..000000000 Binary files a/vignettes/pdf/Rcpp-jss-2011.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-libraries.pdf b/vignettes/pdf/Rcpp-libraries.pdf deleted file mode 100644 index 8ecc1404a..000000000 Binary files a/vignettes/pdf/Rcpp-libraries.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-modules.pdf b/vignettes/pdf/Rcpp-modules.pdf deleted file mode 100644 index 8f7f4cafa..000000000 Binary files a/vignettes/pdf/Rcpp-modules.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-package.pdf b/vignettes/pdf/Rcpp-package.pdf deleted file mode 100644 index eda61fc39..000000000 Binary files a/vignettes/pdf/Rcpp-package.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-quickref.pdf b/vignettes/pdf/Rcpp-quickref.pdf deleted file mode 100644 index ecd3d9d0c..000000000 Binary files a/vignettes/pdf/Rcpp-quickref.pdf and /dev/null differ diff --git a/vignettes/pdf/Rcpp-sugar.pdf b/vignettes/pdf/Rcpp-sugar.pdf deleted file mode 100644 index 0b1d76d08..000000000 Binary files a/vignettes/pdf/Rcpp-sugar.pdf and /dev/null differ diff --git a/vignettes/rmd/Makefile b/vignettes/rmd/Makefile index eb923a854..4de500cf1 100644 --- a/vignettes/rmd/Makefile +++ b/vignettes/rmd/Makefile @@ -7,19 +7,18 @@ rmdvignettes := $(rmdsources:.Rmd=.pdf) %.pdf: %.Rmd Rscript -e 'rmarkdown::render("$<")' Rscript -e 'tools::compactPDF("$@", gs_quality="ebook")' - cp -vax $@ ../pdf + cp -vax $@ .. all: ${rmdvignettes} Rcpp-jss-2011.pdf -Rcpp-jss-2011.tex: Rcpp-jss-2011.Rnw - Rscript -e 'Sweave("$<")' - -Rcpp-jss-2011.pdf: Rcpp-jss-2011.tex - Rscript -e 'tools::texi2pdf("$<", texi2dvi="pdflatex")' +Rcpp-jss-2011.pdf: Rcpp-jss-2011.Rnw + Rscript -e 'Sweave("Rcpp-jss-2011.Rnw")' + pdflatex Rcpp-jss-2011.tex bibtex Rcpp-jss-2011.aux - Rscript -e 'tools::texi2pdf("$<", texi2dvi="pdflatex")' + pdflatex Rcpp-jss-2011.tex + pdflatex Rcpp-jss-2011.tex Rscript -e 'tools::compactPDF("$@", gs_quality="ebook")' - cp -vax $@ ../pdf + cp -vax $@ .. clean: @rm -rf *.aux *.log *.out *.toc *.tex *.pdf Rcpp-introduction_cache Rcpp-libraries_cache pinp.cls Rcpp-jss-2011.bbl Rcpp-jss-2011.blg auto diff --git a/vignettes/rmd/Rcpp-FAQ.Rmd b/vignettes/rmd/Rcpp-FAQ.Rmd index cc8774d61..5e7f01ded 100644 --- a/vignettes/rmd/Rcpp-FAQ.Rmd +++ b/vignettes/rmd/Rcpp-FAQ.Rmd @@ -10,9 +10,9 @@ author: address: - code: a - address: \url{http://dirk.eddelbuettel.com} + address: \url{https://dirk.eddelbuettel.com} - code: b - address: \url{https://romain.rbind.io/} + address: \url{https://github.com/romainfrancois} # For footer text lead_author_surname: Eddelbuettel and François @@ -42,7 +42,7 @@ fontsize: 9pt # Optional: Force one-column layout, default is two-column #one_column: true -# Optional: Enables lineo mode, but only if one_column mode is also true +# Optional: Enables lineno mode, but only if one_column mode is also true #lineno: true # Optional: Enable one-sided layout, default is two-sided @@ -75,7 +75,7 @@ header-includes: > \newcommand{\proglang}[1]{\textsf{#1}} \newcommand{\pkg}[1]{\textbf{#1}} \newcommand{\faq}[1]{FAQ~\ref{#1}} - \newcommand{\rdoc}[2]{\href{http://www.rdocumentation.org/packages/#1/functions/#2}{\code{#2}}} + \newcommand{\rdoc}[2]{\code{#2}} vignette: > %\VignetteIndexEntry{Rcpp-FAQ} @@ -111,7 +111,7 @@ vignette("Rcpp-attributes") ``` If you do not have \pkg{Rcpp} installed, these documents should also be available -whereever you found this document, \textsl{i.e.,} on every mirror site of CRAN. +wherever you found this document, \textsl{i.e.,} on every mirror site of CRAN. ## What do I need @@ -131,7 +131,7 @@ means one needs: `--enable-shared-lib` option; - standard development tools such as `make` etc. -Also see the [RStudio documentation](http://www.rstudio.com/ide/docs/packages/prerequisites) +Also see the [RStudio documentation](https://support.posit.co/hc/en-us/articles/200486498-Package-Development-Prerequisites) on pre-requisites for R package development. ## What compiler can I use {#q:what-compiler} @@ -153,11 +153,11 @@ Specific per-platform notes: manual \citep[Appendix D]{R:Administration}. \item[macOS] users, as noted in the "R Administration" manual \citep[Appendix C.4]{R:Administration}, need to install the Apple Developer Tools - (\textsl{e.g.}, \href{https://developer.apple.com/library/ios/technotes/tn2339/_index.html}{Xcode Command Line Tools} (as well as \texttt{gfortran} if \proglang{R} or + (\textsl{e.g.}, \href{https://developer.apple.com/library/archive/technotes/tn2339/_index.html}{Xcode Command Line Tools} (as well as \texttt{gfortran} if \proglang{R} or Fortran-using packages are to be built); also see \faq{q:OSX} and \faq{q:OSXArma} below. This is frustratingly moving target; consult the \code{r-sig-mac} list (and its archives) for (current) details. - \item[Linux] user need to install the standard developement packages. Some + \item[Linux] user need to install the standard development packages. Some distributions provide helper packages which pull in all the required packages; the \texttt{r-base-dev} package on Debian and Ubuntu is an example. \end{description} @@ -181,7 +181,7 @@ exhaustive as CRAN by now has \textsl{many} helpful packages: Attributes (see \faq{using-attributes} and \faq{prototype-using-attributes}) feature provided by \pkg{Rcpp}; \item[\pkg{RUnit}, \pkg{tinytest}, \pkg{testthat}] can be used for unit - testing; \pkg{Rcpp} uses \pkg{tinytest} as it is ligthweight and installs the + testing; \pkg{Rcpp} uses \pkg{tinytest} as it is lightweight and installs the tests along with the package by default but note that no testing package is \textsl{required}: all are optional; \item[\pkg{rbenchmark}, \pkg{microbenchmark}] to run simple timing @@ -301,12 +301,12 @@ the supplied code and makes it available under the selected identifier. Similarly, \rdoc{Rcpp}{sourceCpp} can read in a file and compile, link and load the code therein. -## How do I convert my prototyped code to a package {#from-inline-to-package} +## How do I convert my prototype code to a package {#from-inline-to-package} Since release 0.3.5 of \pkg{inline}, one can combine \faq{using-inline} and \faq{make-package}. See `help("package.skeleton-methods")` once \pkg{inline} is loaded and use the skeleton-generating functionality to -transform a prototyped function into the minimal structure of a package. +transform a prototype function into the minimal structure of a package. After that you can proceed with working on the package in the spirit of \faq{make-package}. @@ -384,7 +384,7 @@ for you. Note that we always need to set `PKG_CXXFLAGS` (or equally `PKG_CPPFLAGS`) to tell R where the \pkg{Rcpp} headers files are located. -Once `R CMD SHLIB` has created the dyanmically-loadable file (with +Once `R CMD SHLIB` has created the dynamically-loadable file (with extension `.so` on Linux, `.dylib` on macOS or `.dll` on Windows), it can be loaded in an R session via \rdoc{base}{dyn.load}, and the function can be executed via \rdoc{base}{.Call}. Needless to say, we @@ -478,7 +478,7 @@ able to mix. In such cases, it is better to provide collaborators with the By default, the macOS operating environment lacks the ability to parallelize sections of code using the [\proglang{OpenMP} -standard](http://openmp.org/wp/). Within \proglang{R} 3.4.*, the default +standard](https://www.openmp.org/specifications/). Within \proglang{R} 3.4.*, the default developer environment was _changed_ to allow for \proglang{OpenMP} to be used on macOS by using a non-default toolchain provided by R Core Team maintainers for macOS. Having said this, it is still important to protect any reference @@ -516,10 +516,10 @@ Below are additional resources that provide information regarding compiling Rcpp [on the `r-sig-mac` list](https://stat.ethz.ch/pipermail/r-sig-mac/2014-April/010835.html), which is generally recommended for macOS-specific questions and further consultation. 2. Another helpful write-up for installation / compilation on macOS Mavericks is provided - [by the BioConductor project](http://www.bioconductor.org/developers/how-to/mavericks-howto/). + [by the BioConductor project](https://contributions.bioconductor.org/cmavericks-best-practices.html). 3. Lastly, another resource that exists for installation / compilation help is provided at - . + . \textbf{Note:} If you are running into trouble compiling code with \pkg{RcppArmadillo}, please also see \faq{q:OSXArma} listed below. @@ -551,7 +551,7 @@ By now REvolution R is defunct too. Rho, previously known as CXXR, is an ambitious project that aims to totally refactor the \proglang{R} interpreter in \proglang{C++}. There -are a few similaritites with \pkg{Rcpp} but the projects are +are a few similarities with \pkg{Rcpp} but the projects are unrelated. Rho / CXXR and \pkg{Rcpp} both want \proglang{R} to make more use of \proglang{C++} @@ -612,11 +612,11 @@ The following questions were asked on the [Rcpp-devel](https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel) mailing list, which is our preferred place to ask questions as it guarantees exposure to a number of advanced Rcpp users. The -[StackOverflow tag for rcpp](http://stackoverflow.com/questions/tagged/rcpp) +[StackOverflow tag for rcpp](https://stackoverflow.com/questions/tagged/rcpp) is an alternative; that site is also easily searchable. Several dozen fully documented examples are provided at the -[Rcpp Gallery](http://gallery.rcpp.org) -- which is also open for new contributions. +[Rcpp Gallery](https://gallery.rcpp.org) -- which is also open for new contributions. ## Can I use templates with \pkg{Rcpp} @@ -718,7 +718,7 @@ operations. That is a mouthful of words meaning that it makes the code go faster by using fiendishly clever ways available via the so-called template meta programming, an advanced \proglang{C++} technique. Also, the \pkg{RcppEigen} package \citep{JSS:RcppEigen} provides an alternative using the -[Eigen](http://eigen.tuxfamily.org) template library. +[Eigen](https://libeigen.gitlab.io) template library. ### Using inline with RcppArmadillo {#using-inline-armadillo} @@ -757,7 +757,7 @@ The focus is on the code `arma::trans(x) * arma::inv(Y) * z`, which performs the same operation as the R code `t(x) %*% solve(Y) %*% z`, although Armadillo turns it into only one operation, which makes it quite fast. Armadillo benchmarks against other \proglang{C++} matrix algebra libraries -are provided on [the Armadillo website](http://arma.sourceforge.net/speed.html). +are provided on [the Armadillo website](https://arma.sourceforge.net/speed.html). It should be noted that code below depends on the version `0.3.5` of \pkg{inline} and the version `0.2.2` of \pkg{RcppArmadillo}. @@ -896,7 +896,7 @@ C Armadillo supports a full range of common linear algebra operations. The \pkg{RcppEigen} package provides an alternative using the -[Eigen](http://eigen.tuxfamily.org) template library. +[Eigen](https://libeigen.gitlab.io) template library. Rcpp Attributes, once again, makes this even easier: @@ -1065,7 +1065,7 @@ suggestion or fix for casting 64-bit integer values: 32-bit integer values fit into `integer` types, up to 53 bit precision fits into `numeric` and beyond that truly large integers may have to converted (rather crudely) to text and re-parsed. Using a different representation as -for example from the [GNU Multiple Precision Arithmetic Library](http://gmplib.org/) +for example from the [GNU Multiple Precision Arithmetic Library](https://gmplib.org/) may be an alternative. However, with care, and via the package \pkg{bit64}, \proglang{R} can use @@ -1083,7 +1083,7 @@ system. Specific per-platform notes: -- **Windows** users probably want the [MiKTeX](http://miktex.org/). +- **Windows** users probably want the [MiKTeX](https://miktex.org/). Suggestions for a more detailed walk through would be appreciated. - **macOS** users seem to fall into camps which like or do not like brew / homebrew. One suggestion was to install @@ -1109,8 +1109,8 @@ generator scripts to explicitly enumerate arguments, and that number has to stop at some limit. We chose 20. A good discussion is available at -[this StackOverflow question](http://stackoverflow.com/questions/27371543) -concering data.frame creation with \pkg{Rcpp}. One solution offers a custom +[this StackOverflow question](https://stackoverflow.com/questions/27371543) +concerning data.frame creation with \pkg{Rcpp}. One solution offers a custom `ListBuilder` class to circumvent the limit; another suggests to simply nest lists. @@ -1168,10 +1168,10 @@ Note: In `cpp`, the default `bool` values are `true` and But of course. In a nutshell, this boils down to \emph{what your compiler supports}, and also \emph{what R supports}. We expanded a little on this in -[Rcpp Gallery article](http://gallery.rcpp.org/articles/rcpp-and-c++11-c++14-c++17/) providing more detail. What follows in an abridged summary. +[Rcpp Gallery article](https://gallery.rcpp.org/articles/rcpp-and-c++11-c++14-c++17/) providing more detail. What follows in an abridged summary. You can always \emph{locally} set appropriate `PKG_CXXFLAGS` as an -environment variable, or via `~/.R/Makevars`. You can also plugins and/or R +environment variable, or via `~/.R/Makevars`. You can also set plugins and/or R support from `src/Makevars`: - _C++11_: has been supported since early 2013 via a plugin selecting @@ -1201,7 +1201,7 @@ conda install gxx_linux-64 helps within this environment as it installs the corresponding `x86_64-conda_cos6-linux-gnu-c++` compiler. Documentation for this and other systems is provided -[at this page](https://conda.io/docs/user-guide/tasks/build-packages/compiler-tools.html). +[at this page](https://docs.conda.io/docs/user-guide/tasks/build-packages/compiler-tools.html). ## Can I speed up compilation? @@ -1230,16 +1230,16 @@ exclude these different (layered) bits of functionality. You bet. We use \proglang{doxygen} to generate html, latex and man page documentation from the source. The html documentation is available for -[browsing](http://dirk.eddelbuettel.com/code/rcpp/html/index.html), as a -[very large pdf file](http://dirk.eddelbuettel.com/code/rcpp/Rcpp_refman.pdf), +[browsing](https://dirk.eddelbuettel.com/code/rcpp/html/index.html), as a +[very large pdf file](https://dirk.eddelbuettel.com/code/rcpp/Rcpp_refman.pdf), and all three formats are also available a zip-archives: -[html](http://dirk.eddelbuettel.com/code/rcpp/rcpp-doc-html.zip), -[latex](http://dirk.eddelbuettel.com/code/rcpp/rcpp-doc-latex.zip), and -[man](http://dirk.eddelbuettel.com/code/rcpp/rcpp-doc-man.zip). +[html](https://dirk.eddelbuettel.com/code/rcpp/rcpp-doc-html.zip), +[latex](https://dirk.eddelbuettel.com/code/rcpp/rcpp-doc-latex.zip), and +[man](https://dirk.eddelbuettel.com/code/rcpp/rcpp-doc-man.zip). ## Does it really work -We take quality seriously and have developped an extensive unit test suite to +We take quality seriously and have developed an extensive unit test suite to cover many possible uses of the \pkg{Rcpp} API. We are always on the look for more coverage in our testing. Please let us know @@ -1252,13 +1252,12 @@ The mailing list hosted at R-forge is by far the best place. You may also want to look at the list archives to see if your question has been asked before. -You can also use [StackOverflow via its 'rcpp' tag](http://stackoverflow.com/questions/tagged/rcpp). +You can also use [StackOverflow via its 'rcpp' tag](https://stackoverflow.com/questions/tagged/rcpp). ## Where can I read old questions and answers The normal [Rcpp-devel](https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel) -mailing list hosting at R-forge contains an archive, which can be -[searched via swish](http://lists.r-forge.r-project.org/mailman/swish.cgi?query=listname=rcpp-devel). +mailing list hosting at R-forge contains an archive. Alternatively, one can also use [Mail-Archive on Rcpp-devel](http://www.mail-archive.com/rcpp-devel@lists.r-forge.r-project.org/info.html) @@ -1278,7 +1277,7 @@ You can also spread the word about \pkg{Rcpp}. There are many packages on CRAN that use \proglang{C++}, yet are not using \pkg{Rcpp}. You could blog about it, or get the word out otherwise. -Last but not least the [Rcpp Gallery](http://gallery.rcpp.org) is open +Last but not least the [Rcpp Gallery](https://gallery.rcpp.org) is open for user contributions. ## I don't like it. How can I help {#dont-like-help} @@ -1302,7 +1301,7 @@ From late 2008 to late 2013, we used the which contained \pkg{Rcpp} and a number of related packages. It still has the full history as well as number of support files. -We have since switched to a [Git repository at Github](http://github.com/RcppCore/Rcpp) +We have since switched to a [Git repository at Github](https://github.com/RcppCore/Rcpp) for \pkg{Rcpp} (as well as for \pkg{RcppArmadillo} and \pkg{RcppEigen}). # Known Issues @@ -1452,7 +1451,7 @@ circumvented as it is really a pointer to the underlying R object. ## Issues with implicit conversion from an \pkg{Rcpp} object to a scalar or other \pkg{Rcpp} object Not all \pkg{Rcpp} expressions are directly compatible with -`operator=`. Compability issues stem from many \pkg{Rcpp} objects and +`operator=`. Compatibility issues stem from many \pkg{Rcpp} objects and functions returning an intermediary result which requires an explicit conversion. In such cases, the user may need to assist the compiler with the conversion. @@ -1573,7 +1572,7 @@ elements. With the release of \proglang{R}'s 3.0.0, long vector support was adde allow for largest vector possible to increase up to $2^{52}$ elements on x64 bit operating systems (c.f. [Long Vectors help entry](https://stat.ethz.ch/R-manual/R-devel/library/base/html/LongVectors.html)). Once this was established, support for long vectors within the \pkg{Rcpp} paradigm -was introduced with \pkg{Rcpp} version 0.12.0 (c.f [\pkg{Rcpp} 0.12.0 annoucement](http://dirk.eddelbuettel.com/blog/2015/07/25/)). +was introduced with \pkg{Rcpp} version 0.12.0 (c.f [\pkg{Rcpp} 0.12.0 annoucement](https://dirk.eddelbuettel.com/blog/2015/07/25/)). However, the requirement for using long vectors in \pkg{Rcpp} necessitates the presence of compiler support for the `R_xlen_t`, which is platform @@ -1587,7 +1586,7 @@ There are three options to trigger compilation with \proglang{C++11}. The first -- and most likely option to use -- will be the plugin support offered by \pkg{Rcpp} attributes. This can be engaged by adding `// [[Rcpp::plugins(cpp11)]]` to the top of the \proglang{C++} script. -For diagnostic and illustrativative purposes, consider the following code +For diagnostic and illustrative purposes, consider the following code which checks to see if `R_xlen_t` is available on your platform: ```{Rcpp} @@ -1732,7 +1731,7 @@ figure out what routines need to be registered. If an older `RcppExports.R` file is discovered, its out-of-date symbol names get picked up, and registration rules for those symbols get written as well. This will register more symbols for the package than are actually defined, leading to an error. This point has been -discussed at some length both in the GitHub issue tickes, on StackOverflow and +discussed at some length both in the GitHub issue tickets, on StackOverflow and elsewhere. So if your autogenerated file fails, and a `symbols not found` error is reported diff --git a/vignettes/rmd/Rcpp-attributes.Rmd b/vignettes/rmd/Rcpp-attributes.Rmd index f885a4c03..0115031d9 100644 --- a/vignettes/rmd/Rcpp-attributes.Rmd +++ b/vignettes/rmd/Rcpp-attributes.Rmd @@ -12,11 +12,11 @@ author: address: - code: a - address: \url{https://rstudio.com} + address: \url{https://posit.co} - code: b - address: \url{http://dirk.eddelbuettel.com} + address: \url{https://dirk.eddelbuettel.com} - code: c - address: \url{https://romain.rbind.io/} + address: \url{https://github.com/romainfrancois} # For footer text TODO(fold into template, allow free form two-authors) lead_author_surname: Allaire, Eddelbuettel, François @@ -49,7 +49,7 @@ fontsize: 9pt # Optional: Force one-column layout, default is two-column #one_column: true -# Optional: Enables lineo mode, but only if one_column mode is also true +# Optional: Enables lineno mode, but only if one_column mode is also true #lineno: true # Optional: Enable one-sided layout, default is two-sided diff --git a/vignettes/rmd/Rcpp-extending.Rmd b/vignettes/rmd/Rcpp-extending.Rmd index 79b1f79a0..1ff14ed98 100644 --- a/vignettes/rmd/Rcpp-extending.Rmd +++ b/vignettes/rmd/Rcpp-extending.Rmd @@ -10,9 +10,9 @@ author: address: - code: a - address: \url{http://dirk.eddelbuettel.com} + address: \url{https://dirk.eddelbuettel.com} - code: b - address: \url{https://romain.rbind.io/} + address: \url{https://github.com/romainfrancois} # For footer text lead_author_surname: Eddelbuettel and François @@ -46,7 +46,7 @@ fontsize: 9pt # Optional: Force one-column layout, default is two-column #one_column: true -# Optional: Enables lineo mode, but only if one_column mode is also true +# Optional: Enables lineno mode, but only if one_column mode is also true #lineno: true # Optional: Enable one-sided layout, default is two-sided diff --git a/vignettes/rmd/Rcpp-introduction.Rmd b/vignettes/rmd/Rcpp-introduction.Rmd index 4c0afc1f6..638a44678 100644 --- a/vignettes/rmd/Rcpp-introduction.Rmd +++ b/vignettes/rmd/Rcpp-introduction.Rmd @@ -11,9 +11,9 @@ author: affiliation: b address: - code: a - address: Debian and R Projects; Chicago, IL, USA; \url{edd@debian.org} + address: Debian and R Projects; Chicago, IL, USA; \code{edd@debian.org} - code: b - address: Depts of Informatics and Statistics, Univ. of Illinois at Urbana-Champaign; Champaign, IL, USA; \url{balamut2@illinois.edu} + address: Depts of Informatics and Statistics, Univ. of Illinois at Urbana-Champaign; Champaign, IL, USA; \code{balamut2@illinois.edu} # For footer text TODO(fold into template, allow free form two-authors) lead_author_surname: Eddelbuettel and Balamuta @@ -59,7 +59,7 @@ output: pinp::pinp: collapse: true -# Local additiona of a few definitions we use +# Local additions of a few definitions we use header-includes: > \newcommand{\TODO}{\marginnote{TODO}} \newcommand{\rlang}{\textit{R }} @@ -144,7 +144,7 @@ statement is now added: _Interfaces to other software are part of \rlangns_. This last addition is profound. If and when suitable and performant software for a task exists, it is in fact desirable to have a (preferably -also perfomant) interface to this software from \rlangns. +also performant) interface to this software from \rlangns. \cite{Chambers:2016:ExtR} discusses several possible approaches for simpler interfaces and illustrates them with reference implementations to both \python\ and \julia. However, the most performant interface for \rlang is provided at the @@ -155,7 +155,7 @@ analysts and data scientists, aiming to enable them to use---and create--- further _interfaces_ for \rlang which aid the _mission_ while staying true to the _prime directive_. Adding interfaces in such a way is in fact a natural progression from the earliest designs for its predecessor -\slang which was after all designed to provide a more useable 'interface' to +\slang which was after all designed to provide a more usable 'interface' to underlying routines in \fortranns. The rest of the paper is structured as follows. We start by discussing @@ -188,11 +188,10 @@ elements can be obtained in different ways. Some of these are addressed in the _ the Rtools kit provided by R Core available at . Details of these installation steps are beyond the scope of this paper. However, many external resources exist that provide detailed -installation guides for \rlang toolschains in -[Windows](http://thecoatlessprofessor.com/programming/rcpp/install-rtools-for-rcpp/) +installation guides for \rlang toolchains in +[Windows](https://blog.thecoatlessprofessor.com/programming/rcpp/install-rtools-for-rcpp/index.html) and -[macOS](http://thecoatlessprofessor.com/programming/r-compiler-tools-for-rcpp-on-os-x/). - +[macOS](https://blog.thecoatlessprofessor.com/programming/r-compiler-tools-for-rcpp-on-os-x/index.html). As a first step, and chiefly to establish that the toolchain is set up correctly, consider a minimal use case such as the following: @@ -354,7 +353,7 @@ convolve_cpp(const NumericVector& a, To deploy such code from within an \rlang script or session, first save it into a new file---which could be called **convolve.cpp**---in either the working directory, a -temporary directoy or a project directory. Then from within the \rlang session, +temporary directory or a project directory. Then from within the \rlang session, use `Rcpp::sourceCpp("convolve.cpp")` (possibly using a path as well as the filename). This not only compiles, links and loads the code within the external file but also adds the necessary "glue" to make the \rcpp function available in the \rlang environment. Once the @@ -481,7 +480,7 @@ evalCpp("R::rnorm(0, 1)") One important aspect of the behind-the-scenes code generation for the single expression (as well as all code created via _Rcpp Attributes_) is the automatic preservation of the -state of the random nunber generators in \rlangns. This means that from a given seed, we will +state of the random number generators in \rlangns. This means that from a given seed, we will receive _identical_ draws of random numbers whether we access them from \rlang or via \cpp code accessing the same generators (via the \rcpp interfaces). To illustrate, the same number is drawn via \rlang code after resetting the seed: @@ -626,7 +625,7 @@ in place of `sample(n, n, replace = TRUE)` to sample row ids. This is an equivalent substitution since equal weight is being placed upon all row ids and replacement is allowed.\footnote{For more flexibility in sampling see Christian Gunning's Sample extension for \pkg{RcppArmadillo} and -\href{http://gallery.rcpp.org/articles/using-the-Rcpp-based-sample-implementation/}{Rcpp Gallery: Using the \pkg{RcppArmadillo}-based Implementation of R's sample()} or consider using the \code{Rcpp::sample()} sugar function added in 0.12.9 by Nathan Russell.} +\href{https://gallery.rcpp.org/articles/using-the-Rcpp-based-sample-implementation/}{Rcpp Gallery: Using the \pkg{RcppArmadillo}-based Implementation of R's sample()} or consider using the \code{Rcpp::sample()} sugar function added in 0.12.9 by Nathan Russell.} Note that the upper bound of the interval, `n`, will never be reached. While this may seem flawed, it is important to note that vectors and matrices in \cpp use a zero-based indexing system, meaning that they begin at 0 instead of 1 @@ -719,7 +718,7 @@ classes \citep{Sanderson+Curtin:2016} via the \pkg{RcppArmadillo} package running this example, the \pkg{RcppArmadillo} package must be installed using `install.packages('RcppArmadillo')`.\footnote{macOS users may encounter `-lgfortran` and `-lquadmath` errors on compilations with this package if the development environment -is not appropriately set up. \href{https://cran.r-project.org/web/packages/Rcpp/vignettes/Rcpp-FAQ.pdf}{Section 2.16 of the Rcpp FAQ} provides details regarding the necessary `gfortran` binaries.} +is not appropriately set up. \href{https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-FAQ.pdf}{Section 2.16 of the Rcpp FAQ} provides details regarding the necessary `gfortran` binaries.} One important caveat when using additional packages within the \rcpp ecosystem is the correct header file may not be `Rcpp.h`. In a majority of cases, the additional package ships a dedicated header diff --git a/vignettes/rmd/Rcpp-jss-2011.Rnw b/vignettes/rmd/Rcpp-jss-2011.Rnw index 591e62f3f..954c2ceed 100644 --- a/vignettes/rmd/Rcpp-jss-2011.Rnw +++ b/vignettes/rmd/Rcpp-jss-2011.Rnw @@ -40,14 +40,14 @@ Debian Project \\ River Forest, IL, United States of America\\ E-mail: \email{edd@debian.org}\\ - URL: \url{http://dirk.eddelbuettel.com/}\\ + URL: \url{https://dirk.eddelbuettel.com/}\\ Romain Fran\c{c}ois\\ Professional \proglang{R} Enthusiast\\ 1 rue du Puits du Temple\\ 34 000 Montpellier, France \\ E-mail: \email{romain@r-enthusiasts.com}\\ - URL: \url{http://romainfrancois.blog.free.fr/} + URL: \url{https://github.com/romainfrancois} } %% need no \usepackage{Sweave.sty} @@ -101,7 +101,7 @@ as opposed to the traditional \proglang{R} API. Many more examples are available the package, both as explicit examples and as part of the numerous unit tests. % The \pkg{Rcpp} package is available from the Comprehensive \proglang{R} Archive Network (CRAN) -at \url{http://CRAN.R-project.org/package=Rcpp}. +at \url{https://CRAN.R-project.org/package=Rcpp}. \makeatletter \if@nojss diff --git a/vignettes/rmd/Rcpp-libraries.Rmd b/vignettes/rmd/Rcpp-libraries.Rmd index d82b97e42..03c56d050 100644 --- a/vignettes/rmd/Rcpp-libraries.Rmd +++ b/vignettes/rmd/Rcpp-libraries.Rmd @@ -18,7 +18,7 @@ doi_footer: "https://arxiv.org/abs/1911.06416" # Abstract abstract: | - We desribe how we extend R with an external C++ code library by using the Rcpp + We describe how we extend R with an external C++ code library by using the Rcpp package. Our working example uses the recent machine learning library and application 'Corels' providing optimal yet easily interpretable rule lists \citep{arxiv:corels} which we bring to R in the form of the \pkg{RcppCorels} package @@ -107,7 +107,7 @@ involved, so it is useful to check inter-license compatibility, as well as gener usability of the license in question. Several sites can help via license recommendations, and checks for interoperability. One example is the site at [choosealicense.com](https://choosealicense.com/) (which is backed by GitHub) can help, as -can [tldrlegal.com](https://tldrlegal.com/). License choice is a complex topic, and +can [tldrlegal.com](https://www.tldrlegal.com/). License choice is a complex topic, and general recommendations are difficult to make besides the key point of sticking to already-established and known licenses. @@ -141,7 +141,7 @@ The first step in getting a new package combing R and C++ is often the creation Rcpp package. There are several helper functions to choose from. A natural first choice is `Rcpp.package.skeleton()` from the \pkg{Rcpp} package \citep{CRAN:Rcpp}. It can be improved by having the optional helper package \pkg{pkgKitten} \citep{CRAN:pkgKitten} -around as its `kitten()` function smoothes some rougher edges left by the underlying Base +around as its `kitten()` function smooths some rougher edges left by the underlying Base R function `package.skeleton()`. This step is shown below in then appendix, and corresponds to the first commit, followed by a first edit of file `DESCRIPTION`. @@ -154,15 +154,24 @@ it. Given a basic package with C++ support, we can now turn to integrating the external package. This complexity of this step can, as alluded to earlier, vary from very easy to -very complex. Simple cases include just dependending on library headers which can either -be copied to the package, or be provided by another package such as \pkg{BH} -\citep{CRAN:BH}. It may also be a dependency on a fairly standard library available on -most if not all systems. The graphics formats bmp, jpeg or png may be example; text -formats like JSON or XML are another. One difficulty, though, may be that _run-time_ -support does not always guarantee _compile-time_ support. In these cases, a `-dev` or -`-devel` package may need to be installed. +very complex. Simple cases include just depending on library headers which can either be +copied to the package, or be provided by another package such as \pkg{BH} \citep{CRAN:BH} +or \pkg{AsioHeaders} \citep{CRAN:AsioHeaders} or many other examples. -In the concrete case of Corels, we +One aspect worth noting is that if you include a type in your function interface it will +also be part of the generated \code{RcppExports.cpp}. In this case adding a file +\code{PACKAGE\_types.h} (where \code{PACKAGE} is to be replaced with the name of your +package) containing the required \code{\#include} statement for the type(s) will permit +compilation; see the 'Rcpp Attributes' vignette for details \citep{CRAN:Rcpp:Attributes}. + +It may also be a dependency on a fairly standard library available on most if +not all systems. The graphics formats bmp, jpeg or png may be an example; text +formats like JSON or XML are another. One difficulty, though, may be that +_run-time_ support does not always guarantee _compile-time_ support. In these +cases, a `-dev` or `-devel` package may need to be installed. + +Here, we use a third approach and copy files. Discussing the two other means +fully is beyond the scope of this shorter note. So in the concrete case of Corels, we - copied all existing C++ source and header files over into the `src/` directory; - renamed all header files from `*.hh` to `*.h` to comply with an R preference; @@ -243,7 +252,7 @@ fs::dir_tree("../../../rcppcorels/inst/sample_data") ## Set up working example Combining the two preceding steps, we can now offer an illustrative example. It is -included in the helpd page for function `corels()` and can be run from R via +included in the help page for function `corels()` and can be run from R via `example("corels")`. ```r @@ -279,7 +288,7 @@ arguments default values are used. ## Finesse Library Dependencies -One common difficulty when bringing an extermal library to R via a package consists in dealing with +One common difficulty when bringing an external library to R via a package consists in dealing with an external dependency. In the case of 'Corels', the GNU GMP library for multi-precision arithmetic is an optional extension which, if available, improves and accelerates internal processing. diff --git a/vignettes/rmd/Rcpp-modules.Rmd b/vignettes/rmd/Rcpp-modules.Rmd index 29e84988c..364e081a3 100644 --- a/vignettes/rmd/Rcpp-modules.Rmd +++ b/vignettes/rmd/Rcpp-modules.Rmd @@ -1,6 +1,6 @@ --- -title: | - | Exposing \proglang{C++} functions and classes +title: | + | Exposing \proglang{C++} functions and classes | with \pkg{Rcpp} modules # Use letters for affiliations @@ -12,9 +12,9 @@ author: address: - code: a - address: \url{http://dirk.eddelbuettel.com} + address: \url{https://dirk.eddelbuettel.com} - code: b - address: \url{https://romain.rbind.io/} + address: \url{https://github.com/romainfrancois} # For footer text lead_author_surname: Eddelbuettel and François @@ -46,7 +46,7 @@ fontsize: 9pt # Optional: Force one-column layout, default is two-column #one_column: true -# Optional: Enables lineo mode, but only if one_column mode is also true +# Optional: Enables lineno mode, but only if one_column mode is also true #lineno: true # Optional: Enable one-sided layout, default is two-sided @@ -93,7 +93,7 @@ vignette: > Exposing \proglang{C++} functionality to \proglang{R} is greatly facilitated by the \pkg{Rcpp} package and its underlying \proglang{C++} library -\citep{CRAN:Rcpp,JSS:Rcpp}. \pkg{Rcpp} smoothes many of the rough edges in +\citep{CRAN:Rcpp,JSS:Rcpp}. \pkg{Rcpp} smooths many of the rough edges in \proglang{R} and \proglang{C++} integration by replacing the traditional \proglang{R} Application Programming Interface (API) described in '\textsl{Writing R Extensions}' \citep{R:Extensions} with a consistent set of \proglang{C++} @@ -180,7 +180,7 @@ Consider the simple `Uniform` class below: ```cpp class Uniform { public: - Uniform(double min_, double max_) : + Uniform(double min_, double max_) : min(min_), max(max_) {} NumericVector draw(int n) { @@ -203,15 +203,15 @@ with these two functions: using namespace Rcpp; /// create external pointer to a Uniform object -RcppExport SEXP Uniform__new(SEXP min_, +RcppExport SEXP Uniform__new(SEXP min_, SEXP max_) { // convert inputs to appropriate C++ types - double min = as(min_), + double min = as(min_), max = as(max_); - // create pointer to an Uniform object and + // create pointer to an Uniform object and // wrap it as an external pointer - Rcpp::XPtr + Rcpp::XPtr ptr( new Uniform( min, max ), true ); // return the external pointer to the R side @@ -220,7 +220,7 @@ RcppExport SEXP Uniform__new(SEXP min_, /// invoke the draw method RcppExport SEXP Uniform__draw(SEXP xp, SEXP n_) { - // grab the object as a XPtr (smart pointer) + // grab the object as a XPtr (smart pointer) // to Uniform Rcpp::XPtr ptr(xp); @@ -252,7 +252,7 @@ DE 21 Sep 2013: there must a bug somewhere in the vignette processing ```{r, eval=FALSE} f1 <- cxxfunction( , "", includes = unifModCode, plugin = "Rcpp" ) -getDynLib(f1) ## will display info about 'f1' +getDynLib(f1) ## will display info about 'f1' ``` The following listing shows some \textsl{manual} wrapping to access the code, @@ -276,7 +276,7 @@ setMethod("$", "Uniform", function(x, name) { # syntactic sugar to allow new( "Uniform", ... ) setMethod("initialize", "Uniform", function(.Object, ...) { - .Object@pointer <- + .Object@pointer <- .Call(Uniform_method("new"), ...) .Object } ) @@ -295,7 +295,7 @@ class in a way that makes both the internal -# Rcpp modules +# Rcpp modules The design of Rcpp modules has been influenced by \proglang{Python} modules which are generated by the `Boost.Python` library \citep{Abrahams+Grosse-Kunstleve:2003:Boost.Python}. @@ -447,7 +447,7 @@ double norm(double x, double y) { } RCPP_MODULE(mod) { - function("norm", &norm, + function("norm", &norm, "Provides a simple vector norm"); } ``` @@ -475,7 +475,7 @@ double norm(double x, double y) { RCPP_MODULE(mod_formals) { function("norm", &norm, - List::create(_["x"] = 0.0, + List::create(_["x"] = 0.0, _["y"] = 0.0), "Provides a simple vector norm"); } @@ -515,7 +515,7 @@ args(norm) ``` The ellipsis (`...`) can be used to denote that additional arguments -are optional; it does not take a default value. +are optional; it does not take a default value. ```{Rcpp mod_formals3, eval=FALSE} using namespace Rcpp; @@ -539,6 +539,11 @@ norm <- mod$norm args(norm) ``` +As of mid-2024, more recent versions of R no longer tolerate 'empty' strings +as placeholders for missing arguments. It is preferable to simply not list +any arguments for functions that take no arguments. Issue #1322 has an example. + + ## Exposing \proglang{C++} classes using Rcpp modules Rcpp modules also provide a mechanism for exposing \proglang{C++} classes, based @@ -553,7 +558,7 @@ class may be exposed to \proglang{R} as follows: using namespace Rcpp; class Uniform { public: - Uniform(double min_, double max_) : + Uniform(double min_, double max_) : min(min_), max(max_) {} NumericVector draw(int n) const { @@ -680,7 +685,7 @@ The `.field_readonly` exposes a public field with read-only access from \proglan It also accepts the description of the field. ```cpp - .field_readonly("y", &Foo::y, + .field_readonly("y", &Foo::y, "documentation for y") ``` @@ -691,11 +696,11 @@ allowed: ```cpp // with getter and setter - .property("z", &Foo::get_z, + .property("z", &Foo::get_z, &Foo::set_z, "Documentation for z") // with only getter - .property("z", + .property("z", &Foo::get_z, "Documentation for z") ``` @@ -740,7 +745,7 @@ public: } IntegerVector stats() const { - return + return IntegerVector::create(_["read"] = nread, _["write"] = nwrite); } @@ -822,7 +827,7 @@ to restrict the candidate methods. ### Special methods -\pkg{Rcpp} considers the methods `[[` and `[[<-` special, +\pkg{Rcpp} considers the methods `[[` and `[[<-` special, and promotes them to indexing methods on the \proglang{R} side. ### Object finalizers @@ -930,14 +935,14 @@ RCPP_MODULE(yada){ using namespace Rcpp; class_("World") - + // expose the default constructor .constructor() .method("greet", &World::greet) .method("set", &World::set) ; - + } ``` @@ -950,7 +955,7 @@ setMethod("show", yada$World , function(object) { object$greet()) writeLines(msg) } ) -yada$World$new() # implictly calls show +yada$World$new() # implicitly calls show ``` TODO: mention R inheritance (John ?) @@ -1015,24 +1020,24 @@ bar$handleFoo(foo) The following example illustrates how to use Rcpp modules to expose the class `std::vector` from the STL. -```{Rcpp mod_vec, eval=FALSE} -typedef std::vector vec; -void vec_assign(vec* obj, +```{Rcpp mod_vec, eval=FALSE} +typedef std::vector vec; +void vec_assign(vec* obj, Rcpp::NumericVector data) { obj->assign(data.begin(), data.end()); } -void vec_insert(vec* obj, int position, +void vec_insert(vec* obj, int position, Rcpp::NumericVector data) { vec::iterator it = obj->begin() + position; obj->insert(it, data.begin(), data.end()); } -Rcpp::NumericVector vec_asR( vec* obj ) { - return Rcpp::wrap( *obj ); +Rcpp::NumericVector vec_asR( vec* obj ) { + return Rcpp::wrap( *obj ); } -void vec_set(vec* obj, int i, double value) { - obj->at( i ) = value; +void vec_set(vec* obj, int i, double value) { + obj->at( i ) = value; } -// Fix for C++11, where we cannot directly expose +// Fix for C++11, where we cannot directly expose // member functions vec::resize and vec::push_back void vec_resize (vec* obj, int n) { obj->resize(n); @@ -1044,7 +1049,7 @@ void vec_push_back (vec* obj, double value) { RCPP_MODULE(mod_vec) { using namespace Rcpp; - // we expose class std::vector + // we expose class std::vector // as "vec" on the R side class_("vec") @@ -1066,8 +1071,8 @@ RCPP_MODULE(mod_vec) { .const_method("front", &vec::front) .const_method("at", &vec::at ) - // exposing free functions taking a - // std::vector* as their first + // exposing free functions taking a + // std::vector* as their first // argument .method("assign", &vec_assign) .method("insert", &vec_insert) @@ -1231,36 +1236,6 @@ The `loadModule` function has an argument `what` to control which objects are exposed in the package namespace. The special value `TRUE` means that all objects are exposed. -### Deprecated legacy method using loadRcppModules - -Prior to release 0.9.11, where `loadModule` was introduced, -loading all functions and classes from a module -into a package namespace was achieved using the `loadRcppModules` function -within the `.onLoad` body. - -```{r, eval=FALSE} -.onLoad <- function(libname, pkgname) { - loadRcppModules() -} -``` - -This will look in the package's `DESCRIPTION` file for the `RcppModules` -field, load each declared module and populate their contents into the -package's namespace. For example, a package defining modules -`yada`, `stdVector`, `NumEx` would have this declaration: - -``` -RcppModules: yada, stdVector, NumEx -``` - -The `loadRcppModules` function has a single argument `direct` -with a default value of `TRUE`. With this default value, all content -from the module is exposed directly in the package namespace. If set to -`FALSE`, all content is exposed as components of the module. - -Note: This approach is **deprecated** as of Rcpp 0.12.5, and now triggers a -warning message. Eventually this function will be withdrawn. - ### Just expose the module Alternatively to exposing a module's content via `loadModule`, @@ -1346,5 +1321,3 @@ This note introduced \textsl{Rcpp modules} and illustrated how to expose \proglang{C++} function and classes more easily to \proglang{R}. We hope that \proglang{R} and \proglang{C++} programmers find \textsl{Rcpp modules} useful. - - diff --git a/vignettes/rmd/Rcpp-package.Rmd b/vignettes/rmd/Rcpp-package.Rmd index 2930d6622..0533c2b1f 100644 --- a/vignettes/rmd/Rcpp-package.Rmd +++ b/vignettes/rmd/Rcpp-package.Rmd @@ -1,5 +1,5 @@ --- -title: Writing a package that uses \pkg{Rcpp} +title: Writing a package that uses \pkg{Rcpp} # Use letters for affiliations author: @@ -10,9 +10,9 @@ author: address: - code: a - address: \url{http://dirk.eddelbuettel.com} + address: \url{https://dirk.eddelbuettel.com} - code: b - address: \url{https://romain.rbind.io/} + address: \url{https://github.com/romainfrancois} # For footer text lead_author_surname: Eddelbuettel and François @@ -48,7 +48,7 @@ fontsize: 9pt # Optional: Force one-column layout, default is two-column #one_column: true -# Optional: Enables lineo mode, but only if one_column mode is also true +# Optional: Enables lineno mode, but only if one_column mode is also true #lineno: true # Optional: Enable one-sided layout, default is two-sided @@ -76,7 +76,7 @@ header-includes: > \newcommand{\proglang}[1]{\textsf{#1}} \newcommand{\pkg}[1]{\textbf{#1}} \newcommand{\faq}[1]{FAQ~\ref{#1}} - \newcommand{\rdoc}[2]{\href{http://www.rdocumentation.org/packages/#1/functions/#2}{\code{#2}}} + \newcommand{\rdoc}[2]{\code{#2}} \newcommand{\sugar}{\textsl{Rcpp sugar}~} vignette: > @@ -161,13 +161,13 @@ $ \end{ShadedResult} Using \rdoc{Rcpp}{Rcpp.package.skeleton} is by far the simplest approach -as it fulfills two roles. It creates the complete set of files needed for a +as it fulfils two roles. It creates the complete set of files needed for a package, and it also includes the different components needed for using \pkg{Rcpp} that we discuss in the following sections. ## \proglang{C++} code -If the `attributes` argument is set to `TRUE`[^1], the +If the `attributes` argument is set to `TRUE`[^1], the following \proglang{C++} file is included in the `src/` directory: ```cpp @@ -177,9 +177,9 @@ using namespace Rcpp; // [[Rcpp::export]] List rcpp_hello_world() { - CharacterVector x = + CharacterVector x = CharacterVector::create("foo", "bar"); - NumericVector y = + NumericVector y = NumericVector::create( 0.0, 1.0 ) ; List z = List::create( x, y ) ; @@ -240,7 +240,7 @@ that uses the \proglang{C++} function. # 10BE3573-1514-4C36-9D1C-5A225CD40393 rcpp_hello_world <- function() { - .Call('mypackage_rcpp_hello_world', + .Call('mypackage_rcpp_hello_world', PACKAGE = 'mypackage') } ``` @@ -283,7 +283,7 @@ indicates that the client package needs to use header files exposed by ## Now optional: `Makevars` and `Makevars.win` This behaviour changed with \pkg{Rcpp} release 0.11.0. These files used to be -mandatory, now they are merely optional. +mandatory, now they are merely optional. We will describe the old setting first as it was in use for a few years. The new standard, however, is much easier and is described below. @@ -292,7 +292,7 @@ new standard, however, is much easier and is described below. Unfortunately, the `LinkingTo` declaration in itself was not enough to link to the user \proglang{C++} library of \pkg{Rcpp}. Until more -explicit support for libraries is added to \proglang{R}, ones needes to manually +explicit support for libraries is added to \proglang{R}, ones needs to manually add the \pkg{Rcpp} library to the `PKG_LIBS` variable in the `Makevars` and `Makevars.win` files. (This has now changed with release 0.11.0; see below). @@ -324,7 +324,7 @@ PKG_LIBS = $(shell \ As of release 0.11.0, this is no longer needed as client packages obtain the required code from \pkg{Rcpp} via explicit function registration. The user -does not have to do anything. +does not have to do anything. This means that `PKG_LIBS` can now be empty---unless some client libraries are needed. For example, \pkg{RcppCNPy} needs compression support @@ -345,7 +345,7 @@ importFrom(Rcpp, evalCpp) This file serves three purposes. First, it ensure that the dynamic library contained in the package we are creating via \rdoc{Rcpp}{Rcpp.package.skeleton} will be loaded and thereby made -available to the newly created \proglang{R} package. +available to the newly created \proglang{R} package. Second, it declares which functions should be globally visible from the namespace of this package. As a reasonable default, we export all functions. @@ -460,7 +460,7 @@ and \pkg{minqa} \citep{CRAN:minqa}. Several other packages follow older (but sti and appropriate) instructions. They can serve examples on how to get data to and from \proglang{C++} routines, but should not be considered templates for how to connect to \pkg{Rcpp}. The full list of packages using \pkg{Rcpp} can -be found at the [CRAN page](http://CRAN.R-project.org/package=Rcpp) of +be found at the [CRAN page](https://CRAN.R-project.org/package=Rcpp) of \pkg{Rcpp}. # Other compilers @@ -487,5 +487,5 @@ detail, and references to further examples were provided. [^1]: Setting `attributes` to `TRUE` is the default. This document does not cover the behavior of `Rcpp.package.skeleton` when `attributes` is set - to `FALSE` as we try to encourage package developpers to use - attributes. + to `FALSE` as we try to encourage package developers to use + attributes. diff --git a/vignettes/rmd/Rcpp-quickref.Rmd b/vignettes/rmd/Rcpp-quickref.Rmd index 0c5c8ff66..2907427a5 100644 --- a/vignettes/rmd/Rcpp-quickref.Rmd +++ b/vignettes/rmd/Rcpp-quickref.Rmd @@ -10,9 +10,9 @@ author: address: - code: a - address: \url{http://dirk.eddelbuettel.com} + address: \url{https://dirk.eddelbuettel.com} - code: b - address: \url{https://romain.rbind.io/} + address: \url{https://github.com/romainfrancois} # For footer text lead_author_surname: Eddelbuettel and François @@ -41,7 +41,7 @@ fontsize: 9pt # Optional: Force one-column layout, default is two-column #one_column: true -# Optional: Enables lineo mode, but only if one_column mode is also true +# Optional: Enables lineno mode, but only if one_column mode is also true #lineno: true # Optional: Enable one-sided layout, default is two-sided @@ -173,7 +173,7 @@ NumericMatrix zz2 = xx( Range(0,2), Range(0,2)); # Inline C++ Compile in R ```{r, eval = FALSE} -## Note - this is R code. +## Note - this is R code. ## cppFunction in Rcpp allows rapid testing. require(Rcpp) @@ -221,11 +221,11 @@ RcppExport SEXP myCfun( SEXP x, SEXP y) { // Pointer is faster, but changes to xx // propagate to R ( xx -> x == Rx). NumericVector xx(x); - + // clone is slower and uses extra memory. // Safe. No side effects. NumericVector yy(clone(y)); - + xx[0] = yy[0] = -1.5; int zz = xx[0]; @@ -299,18 +299,18 @@ using namespace Rcpp; // [[Rcpp::export]] double muRcpp(NumericVector x){ int n = x.size(); // Size of vector - double sum = 0; // Sum value - + double sum = 0; // Sum value + // For loop, note cpp index shift to 0 - for(int i = 0; i < n; i++){ + for(int i = 0; i < n; i++){ // Shorthand for sum = sum + x[i] - sum += x[i]; + sum += x[i]; } - + return sum/n; // Obtain and return the Mean } -// Place dependent functions above call or +// Place dependent functions above call or // declare the function definition with: double muRcpp(NumericVector x); @@ -320,12 +320,12 @@ double varRcpp(NumericVector x, bool bias = true){ double mean = muRcpp(x); double sum = 0; int n = x.size(); - - for(int i = 0; i < n; i++){ + + for(int i = 0; i < n; i++){ sum += pow(x[i] - mean, 2.0); // Square } - - return sum/(n-bias); // Return variance + + return sum/(n-bias); // Return variance } ``` @@ -397,9 +397,9 @@ RNGScope scope; // For details see Section 6.7.1--Distribution // functions of the `Writing R Extensions' manual. // In some cases (e.g. rnorm), dist-specific -// arguments can be omitted; when in doubt, -// specify all dist-specific arguments. The use -// of doublesrather than integers for dist- +// arguments can be omitted; when in doubt, +// specify all dist-specific arguments. The use +// of doubles rather than integers for dist- // specific arguments is recommended. Unless // explicitly specified, log=FALSE. @@ -477,7 +477,7 @@ Environment e = glob.new_child(); ```cpp // Do NOT expect to have a performance gain -// when calling R functions from R! +// when calling R functions from R! // Retrieve functions from default loaded env. Function rnorm("rnorm"); @@ -485,7 +485,7 @@ rnorm(100, _["mean"] = 10.2, _["sd"] = 3.2 ); // Passing in an R function and obtaining results // Make sure function conforms with return type! -NumericVector callFunction(NumericVector x, +NumericVector callFunction(NumericVector x, Function f) { NumericVector res = f(x); return res; diff --git a/vignettes/rmd/Rcpp-sugar.Rmd b/vignettes/rmd/Rcpp-sugar.Rmd index ff7068507..9384b78a9 100644 --- a/vignettes/rmd/Rcpp-sugar.Rmd +++ b/vignettes/rmd/Rcpp-sugar.Rmd @@ -10,9 +10,9 @@ author: address: - code: a - address: \url{http://dirk.eddelbuettel.com} + address: \url{https://dirk.eddelbuettel.com} - code: b - address: \url{https://romain.rbind.io/} + address: \url{https://github.com/romainfrancois} # For footer text lead_author_surname: Eddelbuettel and François @@ -48,7 +48,7 @@ fontsize: 9pt # Optional: Force one-column layout, default is two-column #one_column: true -# Optional: Enables lineo mode, but only if one_column mode is also true +# Optional: Enables lineno mode, but only if one_column mode is also true #lineno: true # Optional: Enable one-sided layout, default is two-sided @@ -123,7 +123,7 @@ RcppExport SEXP foo(SEXP x, SEXP y) { The goal of the function `foo` code is simple. Given two `numeric` vectors, we create a third one. This is typical low-level -\proglang{C++} code that that could be written much more consicely in +\proglang{C++} code that that could be written much more concisely in \proglang{R} thanks to vectorisation as shown in the next example. ```{r, eval = FALSE} @@ -494,14 +494,14 @@ Note that the parameterization used in these sugar functions may differ between the top-level functions exposed in an \proglang{R} session. For example, the internal \code{rexp} is parameterized by \code{scale}, whereas the R-level \code{stats::rexp} is parameterized by \code{rate}. -Consult \href{http://cran.r-project.org/doc/manuals/r-release/R-exts.html#Distribution-functions}{Distribution Functions} +Consult \href{https://cran.r-project.org/doc/manuals/r-release/R-exts.html#Distribution-functions-1}{Distribution Functions} for more details on the parameterization used for these sugar functions. One point to note is that the programmer using these functions needs to initialize the state of the random number generator as detailed in Section 6.3 of the `Writing R Extensions' manual \citep{R:Extensions}. A nice \proglang{C++} solution for this is to use a \textsl{scoped} class that sets -the random number generatator on entry to a block and resets it on exit. We +the random number generator on entry to a block and resets it on exit. We offer the \code{RNGScope} class which allows code such as ```cpp @@ -591,7 +591,7 @@ public: this)->size(); } - /* definition ommited here */ + /* definition omitted here */ class iterator; inline iterator begin() const { @@ -616,7 +616,7 @@ The `VectorBase` template has three parameters: generated by sugar expressions as these are guaranteed to produce expressions that are without missing values. An example is the `is_na` function. This parameter is used in several places as part - of the compile time dispatch to limit the occurence of redundant + of the compile time dispatch to limit the occurrence of redundant operations. - `VECTOR`: This parameter is the key of \sugar. This is the manifestation of CRTP. The indexing operator and the `size` method diff --git a/vignettes/rmd/Rcpp.bib b/vignettes/rmd/Rcpp.bib index 1aac8921c..568522d4a 100644 --- a/vignettes/rmd/Rcpp.bib +++ b/vignettes/rmd/Rcpp.bib @@ -3,13 +3,14 @@ @String{manuals @String{RCoreTeam = "{R Core Team}" } @String{RFoundation = "R Foundation for Statistical Computing" } @String{R-Forge = "https://R-Forge.R-Project.org/" } +@String{DOI = "10.32614/CRAN.package." } @manual{Abrahams+Grosse-Kunstleve:2003:Boost.Python, author = { David Abrahams and Ralf W. Grosse-Kunstleve }, organization = "Boost Consulting", title = "Building Hybrid Systems with Boost.Python", year = 2003, - url = "https://www.boostpro.com/writing/bpl.pdf" + url = "https://www.boost.org/doc/libs/latest/libs/python/doc/html/article.html" } @Book{Abrahams+Gurtovoy:2004:TemplateMetaprogramming, @@ -59,7 +60,7 @@ @InProceedings{Bates+DebRoy:2001:C++Classes Universit\"at Wien, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch}, year = {2001}, - url = {https://www.ci.tuwien.ac.at/Conferences/DSC-2001/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2001/Proceedings/}, note = {ISSN 1609-395X} } @@ -75,59 +76,75 @@ @Misc{Brokken:2011:Cpp @Manual{CRAN:anytime, title = {anytime: Anything to 'POSIXct' or 'Date' Converter}, author = {Dirk Eddelbuettel}, - year = {2020}, - note = {R package version 0.3.9}, - url = CRAN # "package=anytime" + year = {2025}, + note = {R package version 0.3.12}, + oldurl = CRAN # "package=anytime", + doi = DOI # "anytime" +} + +@Manual{CRAN:AsioHeaders, + title = {'Asio' C++ Header Files}, + author = {Dirk Eddelbuettel}, + year = {2025}, + note = {R package version 1.30.2-1}, + oldurl = CRAN # "package=AsioHeaders", + doi = DOI # "AsioHeaders" } @Manual{CRAN:BH, title = {BH: Boost C++ Header Files}, author = {Dirk Eddelbuettel and John W. Emerson and Michael J. Kane}, - year = {2023}, - note = {R package version 1.81.0-1}, - url = CRAN # "package=BH" + year = {2025}, + note = {R package version 1.90.0-1}, + oldurl = CRAN # "package=BH", + doi = DOI # "BH" } @Manual{CRAN:Matrix, title = {\pkg{Matrix}: Sparse and Dense Matrix Classes and Methods}, author = {Douglas Bates and Martin Maechler}, - year = 2023, - note = {R package version 1.6-4}, - url = CRAN # "package=Matrix" + year = 2026, + note = {R package version 1.7-5}, + oldurl = CRAN # "package=Matrix", + doi = DOI # "Matrix" } @Manual{CRAN:RInside, title = {RInside: C++ classes to embed R in C++ applications}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2020, - note = {R package version 0.2.16}, - url = CRAN # "package=RInside" + year = 2025, + note = {R package version 0.2.19}, + oldurl = CRAN # "package=RInside", + doi = DOI # "RInside" } @Manual{CRAN:RProtoBuf, title = {RProtoBuf: R Interface to the Protocol Buffers API}, author = {Romain Fran\c{c}ois and Dirk Eddelbuettel and Murray Stokely and Jeroen Ooms}, - year = 2023, - note = {R package version 0.4.21}, - url = CRAN # "package=RProtoBuf" + year = 2025, + note = {R package version 0.4.24}, + oldurl = CRAN # "package=RProtoBuf", + doi = DOI # "RProtoBuf" } @Manual{CRAN:RQuantLib, - title = {RQuantLib: {R} interface to the {QuantLib} library}, + title = {RQuantLib: {R} Interface to the {QuantLib} Library}, author = {Dirk Eddelbuettel and Khanh Nguyen and Terry Leitch}, - year = 2023, - note = {R package version 0.4.20}, - url = CRAN # "package=RQuantLib" + year = 2025, + note = {R package version 0.4.26}, + oldurl = CRAN # "package=RQuantLib", + doi = DOI # "RQuantLib" } @Manual{CRAN:RUnit, title = {RUnit: R Unit Test Framework}, author = {Matthias Burger and Klaus Juenemann and Thomas Koenig}, - year = 2018, - note = {R package version 0.4.32}, - url = CRAN # "package=RUnit" + year = 2024, + note = {R package version 0.4.33.1}, + oldurl = CRAN # "package=RUnit", + doi = DOI # "RUnit" } @Manual{CRAN:Rcpp, @@ -135,9 +152,10 @@ @Manual{CRAN:Rcpp author = {Dirk Eddelbuettel and Romain Fran\c{c}ois and JJ Allaire and Kevin Ushey and Qiang Kou and Nathan Russel and John Chambers and Douglas Bates}, - year = 2024, - note = {R package version 1.0.13}, - url = CRAN # "package=Rcpp" + year = 2026, + note = {R package version 1.1.1}, + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Attributes, @@ -145,72 +163,80 @@ @Manual{CRAN:Rcpp:Attributes author = {J. J. Allaire and Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {{Rcpp} Attributes}, - year = 2023, + year = 2026, note = {Vignette included in R package Rcpp}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:FAQ, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Frequently Asked Questions About {Rcpp}}, - year = 2023, + year = 2026, note = {Vignette included in R package {Rcpp}}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Libraries, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel}, title = {Thirteen Simple Steps for Creating An R Package with an External C++ Library }, - year = 2023, + year = 2026, note = {Vignette included in R package Rcpp}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Modules, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Exposing {C++} functions and classes with {Rcpp} modules}, - year = 2023, + year = 2026, note = {Vignette included in R package Rcpp}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Package, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Writing a package that uses {Rcpp}}, - year = 2023, + year = 2026, note = {Vignette included in R package {Rcpp}}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Sugar, crossref = {CRAN:Rcpp}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {Rcpp syntactic sugar}, - year = 2023, + year = 2026, note = {Vignette included in R package {Rcpp}}, - url = CRAN # "package=Rcpp" + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:RcppArmadillo, - title = {RcppArmadillo: Rcpp integration for Armadillo - templated linear algebra library}, + title = {RcppArmadillo: Rcpp Integration for the Armadillo + Templated Linear Algebra Library}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois and Douglas Bates and Binxiang Ni and Conrad Sanderson}, - year = 2023, - note = {R package version 0.12.6.6.1}, - url = CRAN # "package=RcppArmadillo" + year = 2025, + note = {R package version 15.2.3-1}, + oldurl = CRAN # "package=RcppArmadillo", + doi = DOI # "RcppArmadillo" } @Manual{CRAN:RcppCCTZ, title = {RcppCCTZ: Rcpp Bindings for the CCTZ Library}, author = {Dirk Eddelbuettel}, - year = 2022, - note = {R package version 0.2.12}, - url = CRAN # "package=RcppCCTZ" + year = 2024, + note = {R package version 0.2.13}, + oldurl = CRAN # "package=RcppCCTZ", + doi = DOI # "RcppCCTZ" } @Manual{CRAN:RcppClassic, @@ -218,73 +244,82 @@ @Manual{CRAN:RcppClassic author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, year = 2022, note = {R package version 0.9.13}, - url = CRAN # "package=RcppClassic" + oldurl = CRAN # "package=RcppClassic", + doi = DOI # "RcppClassic" } @Manual{CRAN:RcppDate, title = {RcppDate: 'date' C++ Header Libary for Date and Time Functionality}, author = {Dirk Eddelbuettel}, - year = 2021, - note = {R package version 0.0.3}, - url = CRAN # "package=RcppDate" + year = 2025, + note = {R package version 0.0.6}, + oldurl = CRAN # "package=RcppDate", + doi = DOI # "RcppDate" } @Manual{CRAN:RcppDE, - title = {RcppDE: Global optimization by differential evolution in C++}, + title = {RcppDE: Global Optimization by Differential Evolution in C++}, author = {Dirk Eddelbuettel}, - year = 2022, - note = {R package version 0.1.7}, - url = CRAN # "package=RcppDE" + year = 2026, + note = {R package version 0.1.9}, + oldurl = CRAN # "package=RcppDE", + doi = DOI # "RcppDE" } @Manual{CRAN:RcppEigen, - title = {RcppEigen: Rcpp integration for the Eigen templated linear - algebra library}, + title = {RcppEigen: Rcpp Integration for the Eigen Templated Linear + Algebra Library}, author = {Douglas Bates and Dirk Eddelbuettel and Romain Fran\c{c}ois and Yixuan Qiu}, - year = 2023, - note = {{R} package version 0.3.3.9.4}, - url = CRAN # "package=RcppEigen" + year = 2024, + note = {{R} package version 0.3.4.0.2}, + oldurl = CRAN # "package=RcppEigen", + doi = DOI # "RcppEigen" } @Manual{CRAN:RcppExamples, title = {RcppExamples: Examples using {Rcpp} to interface {R} and {C++}}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2019, - note = {R package version 0.1.9}, - url = CRAN # "package=RcppExamples" + year = 2025, + note = {R package version 0.1.10}, + oldurl = CRAN # "package=RcppExamples", + doi = DOI # "RcppExamples" } @Manual{CRAN:RcppGSL, - title = {RcppGSL: Rcpp integration for GNU GSL vectors and matrices}, + title = {RcppGSL: Rcpp Integration for GNU GSL Vectors and Matrices}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2021, - note = {R package version 0.3.10}, - url = CRAN # "package=RcppGSL" + year = 2026, + note = {R package version 0.3.14}, + oldurl = CRAN # "package=RcppGSL", + doi = DOI # "RcppGSL" } @Manual{CRAN:RcppInt64, title = {RppInt64: Rcpp-Based Helper Functions to Pass Int64 and nanotime Values Between R and C++}, author = {Dirk Eddelbuettel}, - year = 2023, - note = {R package version 0.0.4}, - url = CRAN # "package=RcppInt64" + year = 2024, + note = {R package version 0.0.5}, + oldurl = CRAN # "package=RcppInt64", + doi = DOI # "RcppInt64" } @Manual{CRAN:RcppZiggurat, title = {RcppZiggurat: Rcpp Integration of Different Ziggurat Normal RNG Implementations}, author = {Dirk Eddelbuettel}, - year = 2020, - note = {R package version 0.1.6}, - url = CRAN # "package=RcppZiggurat" + year = 2025, + note = {R package version 0.1.8}, + oldurl = CRAN # "package=RcppZiggurat", + doi = DOI # "RcppZiggurat" } @Manual{CRAN:Rserve, - title = {Rserve: Binary R server}, + title = {Rserve: Versatile R Server}, author = {Simon Urbanek}, - year = 2023, - note = {R package version 1.8-13}, - url = CRAN # "package=Rserve" + year = 2025, + note = {R package version 1.8-16}, + oldurl = CRAN # "package=Rserve", + doi = DOI # "Rserve" } @Manual{CRAN:cxxPack, @@ -293,78 +328,87 @@ @Manual{CRAN:cxxPack author = {Dominick Samperi}, year = 2010, note = {R package version 7.0.6}, - url = CRAN # "package=cxxPack" + oldurl = CRAN # "package=cxxPack", + doi = DOI # "cxxPack" } @Manual{CRAN:devtools, title = {devtools: Tools to Make Developing R Packages Easier}, author = {Hadley Wickham and Jim Hester and Winston Chang}, - year = 2022, - note = {R package version 2.4.5}, - url = CRAN # "package=devtools" + year = 2025, + note = {R package version 2.4.6}, + oldurl = CRAN # "package=devtools", + doi = DOI # "devtools" } @Manual{CRAN:highlight, - title = {highlight: Syntax highlighter}, + title = {highlight: Syntax Highlighter}, author = {Hadley Wickham and Romain Fran\c{c}ois and Andre Simon}, - year = 2023, - note = {R package with version 0.5.1}, - url = CRAN # "package=highlight" + year = 2025, + note = {R package with version 0.5.2}, + oldurl = CRAN # "package=highlight", + doi = DOI # "highlight" } @Manual{CRAN:inline, - title = {inline: Inline C, C++, Fortran function calls from + title = {inline: Functions to Inline C, C++, Fortran Function Calls from R}, author = {Oleg Sklyar and Duncan Murdoch and Mike Smith and Dirk Eddelbuettel and Romain Fran\c{c}ois and Karline Soetaert and Johannes Ranke}, - year = 2021, - note = {R package version 0.3.19}, - url = CRAN # "package=inline" + year = 2025, + note = {R package version 0.3.21}, + oldurl = CRAN # "package=inline", + doi = DOI # "inline" } @Manual{CRAN:littler, title = {littler: {R} at the {Command-Line} via r}, author = {Dirk Eddelbuettel and Jeffrey Horner}, - year = 2023, - note = {R package version 0.3.19}, - url = CRAN # "package=littler" + year = 2025, + note = {R package version 0.3.21}, + oldurl = CRAN # "package=littler", + doi = DOI # "littler" } @Manual{CRAN:microbenchmark, title = {microbenchmark: Accurate Timing Functions}, author = {Olaf Mersmann}, year = 2023, - note = {R package version 1.4-10}, - url = CRAN # "package=microbenchmark" + note = {R package version 1.5-0}, + oldurl = CRAN # "package=microbenchmark", + doi = DOI # "microbenchmark" } @Manual{CRAN:minqa, - title = {minqa: Derivative-free optimization algorithms by - quadratic approximation}, + title = {minqa: Derivative-Free Optimization Algorithms by + Quadratic Approximation}, author = {Douglas Bates and Katharine M. Mullen and John C. Nash and Ravi Varadhan}, - year = 2023, - note = {R package version 1.2.6}, - url = CRAN # "package=minqa" + year = 2024, + note = {R package version 1.2.8}, + oldurl = CRAN # "package=minqa", + doi = DOI # "minqa" } @Manual{CRAN:pkgKitten, title = {pkgKitten: Create Simple Packages Which Do not Upset R Package Checks}, author = {Dirk Eddelbuettel}, - year = {2023}, - note = {R package version 0.2.3}, - url = CRAN # "package=pkgKitten" + year = {2024}, + note = {R package version 0.2.4}, + oldurl = CRAN # "package=pkgKitten", + doi = DOI # "pkgKitten" } @Manual{CRAN:profvis, title = {profvis: Interactive Visualizations for Profiling R Code}, author = {Winston Chang and Javier Luraschi and and Timothy Mastny}, - year = 2023, - note = {R package version 0.3.8}, - url = CRAN # "package=profvis" + year = 2024, + note = {R package version 0.4.0}, + oldurl = CRAN # "package=profvis", + doi = DOI # "profvis" } @Manual{CRAN:rbenchmark, @@ -372,15 +416,17 @@ @Manual{CRAN:rbenchmark author = {Wacek Kusnierczyk}, year = 2012, note = {R package version 1.0.0}, - url = CRAN # "package=rbenchmark" + oldurl = CRAN # "package=rbenchmark", + doi = DOI # "rbenchmark" } @Manual{CRAN:roxygen2, - title = {roxygen2: In-source documentation for R}, + title = {roxygen2: In-Line documentation for R}, author = {Hadley Wickham and Peter Danenberg and G\a'bor Cs\a'rdi and Manuel Eugster}, - year = 2022, - note = {R package version 7.2.3}, - url = CRAN # "package=roxygen2" + year = 2025, + note = {R package version 7.3.3}, + oldurl = CRAN # "package=roxygen2", + doi = DOI # "roxygen2" } @Article{CRAN:testthat, @@ -489,7 +535,8 @@ @Book{Eddelbuettel:2013:Rcpp series = {Use R!}, year = 2013, address = {New York}, - isbn = {978-1-4614-6867-7} + isbn = {978-1-4614-6867-7}, + doi = {10.1007/978-1-4614-6868-4} } @article{Efron:1979:Bootstrap, @@ -508,7 +555,7 @@ @MISC{Eigen:Web author = {Ga\"{e}l Guennebaud and Beno\^{i}t Jacob and others}, title = {Eigen v3}, year = 2012, - url = {https://eigen.tuxfamily.org} + url = {https://libeigen.gitlib.io/} } @Manual{GSL, @@ -727,8 +774,8 @@ @Article{PeerJ:Rcpp issue = {e3188v1}, year = 2017, month = {August}, - url = {https://doi.org/10.7287/peerj.preprints.3188v1/}, - doi = {10.7287/peerj.preprints.3188v1/} + url = {https://peerj.com/preprints/3188v1/}, + doi = {10.7287/peerj.preprints.3188v1} } @Book{Plauger+Et+Al:2000:STL, @@ -744,16 +791,17 @@ @manual{QuantLib author = {{QuantLib Core Team}}, year = 2021, title = {QuantLib: a free/open-source library for quantitative finance}, - url = {https://quantlib.org} + url = {https://www.quantlib.org} } @manual{R:Administration, author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "R Installation and Administration", annote = {{ISBN} 3-900051-09-7}, + doi = "10.32614/R.manuals", url = manuals # "R-admin.html" } @@ -761,9 +809,10 @@ @manual{R:Extensions author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "Writing R extensions", annote = {{ISBN} 3-900051-11-9}, + doi = "10.32614/R.manuals", url = manuals # "R-exts.html" } @@ -771,9 +820,10 @@ @manual{R:Internals author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "R internals", annote = {{ISBN} 3-900051-14-3}, + doi = "10.32614/R.manuals", url = manuals # "R-ints.html" } @@ -781,9 +831,10 @@ @manual{R:Language author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, title = "R language", annote = {{ISBN} 3-900051-13-5}, + doi = "10.32614/R.manuals", url = manuals # "R-lang.html" } @@ -793,7 +844,8 @@ @Manual{R:Main author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2023, + year = 2025, + doi = "10.32614/R.manuals", url = {https://www.R-project.org/} } @@ -835,7 +887,7 @@ @TechReport{Sanderson:2010:Armadillo Experiments }, institution = {{NICTA}}, year = 2010, - url = "https://arma.sf.net" + url = "https://arma.sourceforge.net" } @Book{Stroustrup:1997:Cpp, @@ -901,7 +953,7 @@ @InProceedings{Urbanek:2003:Rserve Statistical Computing, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch and Achim Zeileis}, year = {2003}, - url = {https://www.ci.tuwien.ac.at/Conferences/DSC-2003/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2003/Proceedings/}, note = {{ISSN 1609-395X}} } @@ -945,7 +997,7 @@ @Book{Venables+Ripley:2002:MASS address = {New York}, year = 2002, note = {ISBN 0-387-95457-0}, - url = {https://www.stats.ox.ac.uk/pub/MASS4}, + url = {https://www.stats.ox.ac.uk/pub/MASS4/}, } @misc{arxiv:corels, @@ -954,7 +1006,7 @@ @misc{arxiv:corels author = {Elaine Angelino and Nicholas Larus-Stone and Daniel Alabi and Margo Seltzer and Cynthia Rudin}, year = 2017, - howpublished = {\href{https://www.arxiv.org/1704.01701}{arXiv:1704.01701}}, + howpublished = {\href{https://arxiv.org/abs/1704.01701}{arXiv:1704.01701}}, archivePrefix ={arXiv}, primaryClass = {stat.ML} } @@ -962,7 +1014,7 @@ @misc{arxiv:corels @Misc{github:corels, author = {Nicholas Laurus-Stone}, title = {corels: {Learning Certifiably Optimal Rule Lists}}, - howpublished = {\url{https://github.com/nlarusstone/corels}. Also online at \url{https://corels.eecs.harvard.edu/corels/}}, + howpublished = {\url{https://github.com/corels/corels}. Also online at \url{https://corels.cs.ubc.ca/corels/Larus-Stone_thesis.pdf}}, month = 06, year = 2019 } @@ -970,7 +1022,7 @@ @Misc{github:corels @Misc{github:rcppcorels, author = {Dirk Eddelbuettel}, title = {RcppCorels: R binding for the 'Certifiably Optimal RulE ListS (Corels)' Learner}, - howpublished = {\url{https://github.com/eddelbuettel/rcppcorels}}, + howpublished = {\url{https://github.com/corels/rcppcorels}}, month = 11, year = 2019 } diff --git a/vignettes/rmd/getCurrentVersionsOfCitedPackages.R b/vignettes/rmd/getCurrentVersionsOfCitedPackages.R index cbc3be29b..f7d265d57 100755 --- a/vignettes/rmd/getCurrentVersionsOfCitedPackages.R +++ b/vignettes/rmd/getCurrentVersionsOfCitedPackages.R @@ -5,7 +5,7 @@ library(data.table) if (!file.exists("Rcpp.bib")) setwd("~/git/rcpp/vignettes/rmd") -cmd <- "awk '/package=/ { print($5) }' Rcpp.bib | sed -e 's/\"//g' - | awk -F= '{print($2)}' | sort | uniq" +cmd <- "awk '/package=/ { print($5) }' Rcpp.bib | sed -e 's/\"//g' - | awk -F= '{print($2)}' | sed -e 's/,$//' - | sort -f | uniq" con <- pipe(cmd) pkgs <- readLines(con) close(con) @@ -14,4 +14,4 @@ pkg <- data.table(Package=pkgs) db <- data.table(tools::CRAN_package_db()) -print(db[pkg, on="Package"][, .(Package, Version, Date)]) +print(db[pkg, on="Package"][, .(Package, Version, Date, Title)])