diff --git a/.Rbuildignore b/.Rbuildignore index ad49a9aa3..8a7f48938 100644 --- a/.Rbuildignore +++ b/.Rbuildignore @@ -17,10 +17,16 @@ vignettes/getCurrentVersionsOfCitedPackages.R inst/include/Rcpp.h.new inst/include/Rcpp.h.old LICENSE -.*.tar.gz +.*\.tar\.gz$ \.editorconfig docker ^GPATH ^GRTAGS ^GTAGS ^local +vignettes/Makefile +vignettes/rmd +\.github +^issue.*\.md +^note.*\.md +\.vscode diff --git a/.codecov.yml b/.codecov.yml index b1699134e..e10eb4a78 100644 --- a/.codecov.yml +++ b/.codecov.yml @@ -1,7 +1,21 @@ -comment: - layout: "header, diff, tree, changes" - behavior: default - require_changes: false # if true: only post the comment if coverage changes - branches: null - flags: null - paths: null +comment: false + +coverage: + status: + project: + default: + target: 70% # the (on purpose low) required coverage value + threshold: 2% # the permitted delta in hitting the target + patch: + 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 +# branches: null +# flags: null +# paths: null diff --git a/.gitattributes b/.gitattributes index 0148eb62c..0d3b3d5db 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,5 @@ ChangeLog merge=union inst/NEWS.Rd merge=union + +# gitattribute override for linguist +*.h linguist-language=C++ diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md new file mode 100644 index 000000000..51369d05d --- /dev/null +++ b/.github/CONTRIBUTING.md @@ -0,0 +1,9 @@ + +### Contributing to Rcpp + +Please see the file [Contributing](https://github.com/RcppCore/Rcpp/blob/master/Contributing.md) for details on + +- how to report an issue: a [Minimally Complete (and) Verifiable Example (MCVE)](https://stackoverflow.com/questions/5963269/how-to-make-a-great-r-reproducible-example) helps a lot; +- how to submit a pull request: post an issue first, get consensus about _what_ and _how_; +- how to follow our (informal) coding style: simply do as other files do and do not invent a new style; +- how to be nice and add [ChangeLog](https://github.com/RcppCore/Rcpp/blob/master/ChangeLog) and [NEWS.Rd](https://github.com/RcppCore/Rcpp/blob/master/ChangeLog). diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 000000000..83387190d --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1 @@ +github: eddelbuettel diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md new file mode 100644 index 000000000..b3944d4ad --- /dev/null +++ b/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,16 @@ + +### Reporting an Issue + +Make use of the *Preview* tab just above! + +#### Before filing an issue with Rcpp, please ensure that you + +- searched the mailing list archives for the [rcpp-devel](https://lists.r-forge.r-project.org/cgi-bin/mailman/listinfo/rcpp-devel) list for the question you want to ask about; you can do this at at Google with the `site:` qualifier as in this simple example: `site:lists.r-forge.r-project.org rcpp-devel how do I declare a const vector`; + +- searched the [StackOverflow](https://stackoverflow.com/) `[rcpp]` tag _e.g._ via `[rcpp] how do I sample a vector`; + +- searched existing [GitHub issues](https://github.com/RcppCore/Rcpp/issues) which can be searched among open and closed ones; + +- read the [Contributing](https://github.com/RcppCore/Rcpp/blob/master/Contributing.md) page for details on preferred reporting and style; + +If you have the above, remove the text above and provide a [Minimally Complete and Verifiable Example (MCVE)](https://stackoverflow.com/help/minimal-reproducible-example), the output of `sessionInfo()` plus relevant information about the C++ compiler. All this takes a little bit of effort---but greatly increases your chances of getting an applicable and helpful follow-up in return. diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md new file mode 100644 index 000000000..34891f791 --- /dev/null +++ b/.github/PULL_REQUEST_TEMPLATE.md @@ -0,0 +1,11 @@ + +### Pull Request Template for Rcpp + +Please explain the changes you want to apply to Rcpp, preferably in an issue ticket **before** you create a pull request. See the file [Contributing](https://github.com/RcppCore/Rcpp/blob/master/Contributing.md) and the other templates for details. + +#### Checklist + +- [ ] Code compiles correctly +- [ ] `R CMD check` still passes all tests +- [ ] Preferably, new tests were added which fail without the change +- [ ] Document the changes by file in [ChangeLog](https://github.com/RcppCore/Rcpp/blob/master/ChangeLog) diff --git a/.github/workflows/ci.yaml b/.github/workflows/ci.yaml new file mode 100644 index 000000000..ff9bc220f --- /dev/null +++ b/.github/workflows/ci.yaml @@ -0,0 +1,80 @@ +# Run CI for R using https://eddelbuettel.github.io/r-ci/ +# This file is a slight variant by running a matrix of containers + +name: ci + +on: + push: + pull_request: + +env: + USE_BSPM: "true" + _R_CHECK_FORCE_SUGGESTS_: "false" + +jobs: + ci: + + runs-on: ubuntu-latest + + container: + image: ${{ matrix.cntr }} + + strategy: + matrix: + include: + - 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 + - name: r-4.2 + cntr: rcpp/ci-4.2 + r: R + - name: r-4.1 + cntr: rcpp/ci-4.1 + r: R + - name: r-4.0 + cntr: rcpp/ci-4.0 + r: R + - name: r-3.6 + cntr: rcpp/ci-3.6 + r: R + - name: r-3.5 + cntr: rcpp/ci-3.5 + r: R + - name: dev + cntr: rcpp/ci-dev + r: RD + + steps: + - uses: actions/checkout@v5 + + - name: SessionInfo + run: ${{ matrix.r }} -q -e 'sessionInfo()' + + - name: Build + run: ${{matrix.r }} CMD build --no-build-vignettes --no-manual . + + - 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@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 new file mode 100644 index 000000000..5ac954e67 --- /dev/null +++ b/.github/workflows/docker.yaml @@ -0,0 +1,91 @@ +name: docker + +on: + push: + branches: + - master + workflow_dispatch: + schedule: + - cron: "32 1 * * 6" + +jobs: + docker-ci: + runs-on: ubuntu-latest + name: ${{ matrix.tag }} + + strategy: + fail-fast: false + matrix: + tag: [ci, ci-dev] + + steps: + - name: Checkout + uses: actions/checkout@v6 + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v2 + + - name: Login to DockerHub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + + - name: Build and push + uses: docker/build-push-action@v3 + with: + push: true + context: docker/${{ matrix.tag }} + tags: rcpp/${{ matrix.tag }} + + + docker-run: + runs-on: ubuntu-latest + name: run + needs: docker-ci + + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v2 + + - name: Login to DockerHub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + + - name: Build and push + uses: docker/build-push-action@v3 + with: + push: true + context: docker/run + tags: rcpp/run + + + docker-plus: + runs-on: ubuntu-latest + name: plus + needs: docker-run + + steps: + - name: Checkout + uses: actions/checkout@v3 + + - name: Set up Docker Buildx + uses: docker/setup-buildx-action@v2 + + - name: Login to DockerHub + uses: docker/login-action@v2 + with: + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + + - name: Build and push + uses: docker/build-push-action@v3 + with: + push: true + context: docker/plus + tags: rcpp/plus 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/.github/workflows/stale.yaml b/.github/workflows/stale.yaml new file mode 100644 index 000000000..1f73e3641 --- /dev/null +++ b/.github/workflows/stale.yaml @@ -0,0 +1,28 @@ +# Mark stale issues and pull requests +# cf https://github.com/actions/stale + +name: stale + +on: + schedule: + - cron: "11 1 * * 6" + +jobs: + stale: + runs-on: ubuntu-latest + steps: + - uses: actions/stale@v8 + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + stale-issue-label: 'no-issue-activity' + stale-pr-label: 'no-pr-activity' + days-before-stale: 365 + days-before-close: 31 + stale-issue-message: > + This issue is stale (365 days without activity) and will be closed + in 31 days unless new activity is seen. Please feel free to re-open + it is still a concern, possibly with additional data. + stale-pr-message: > + This pull request is is stale (365 days without activity) and will + be closed in 31 days unless new activity is seen. Please feel free + to open a new issue to discuss a fresh approach. diff --git a/.gitignore b/.gitignore index 4334350fb..e93d0f4c2 100644 --- a/.gitignore +++ b/.gitignore @@ -25,3 +25,13 @@ GTAGS ## local/ + +## docker helpers +docker/*sh +docker/*/*.sh + +## Emacs +*~ + +## VSCode +.vscode/ diff --git a/.travis.yml b/.travis.yml deleted file mode 100644 index df28e3ee0..000000000 --- a/.travis.yml +++ /dev/null @@ -1,35 +0,0 @@ -# Run Travis CI for R via Docker -# -# Made by Dirk Eddelbuettel in August 2018 and released under GPL (>=2) - -os: linux -dist: trusty -sudo: required -services: docker - -env: - global: - - DOCKER_OPTS="--rm -ti -v $(pwd):/mnt -w /mnt" - DOCKER_CNTR="rcpp/ci" - R_BLD_OPTS="--no-build-vignettes --no-manual" - R_CHK_OPTS="--no-vignettes --no-manual" - -before_install: - - docker pull ${DOCKER_CNTR} - - docker run ${DOCKER_OPTS} ${DOCKER_CNTR} r -p -e 'sessionInfo()' - -install: - - docker run ${DOCKER_OPTS} ${DOCKER_CNTR} R CMD build ${R_BLD_OPTS} . - -script: - - docker run ${DOCKER_OPTS} ${DOCKER_CNTR} R CMD check ${R_CHK_OPTS} Rcpp_*.tar.gz - -after_success: - - docker run ${DOCKER_OPTS} ${DOCKER_CNTR} r -l covr -e 'codecov()' - -notifications: - email: - on_success: change - on_failure: change - slack: - secure: kUzgzzpgBMc6a+qSjGovfU14U7x9GUXfghDgyF5qBaND/MjFpkmTBfW438Out2buiY+hFNnZc4zThifJM300cOXbcwVentmzuVQ5lLjBhTDvwQgdqytgWr/Ds9dErBeMXr178UD3MJXSOCLhO0wUke2xp2ZsDhsjquT+vFYnuk8= diff --git a/ChangeLog b/ChangeLog index 796519321..c982a2570 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,64 +1,2450 @@ +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 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + +2024-07-07 Kevin Ushey + + * inst/include/Rcpp/internal/SEXP_Iterator.h: Avoid using VECTOR_PTR + * inst/include/Rcpp/vector/Subsetter.h: Avoid using STRING_PTR + * inst/include/RcppCommon.h: Include compatibility defines + * 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 + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2024-06-11 Kevin Ushey + + * inst/include/Rcpp/internal/r_vector.h: Use template specializations to + avoid DATAPTR usage + * inst/include/Rcpp/vector/traits.h: Implement bounds checks in + r_vector_cache access + * inst/tinytest/cpp/Vector.cpp: Add unit tests + * inst/tinytest/test_vector.R: Add unit tests + * tests/tinytest.R: Test in serial by default + +2024-06-02 Dirk Eddelbuettel + + * inst/include/Rcpp/internal/export.h: More R_xlen_t switching + * inst/include/Rcpp/vector/SubMatrix.h: Idem + * inst/include/Rcpp/vector/Vector.h: Idem + +2024-06-01 Dirk Eddelbuettel + + * inst/include/Rcpp/internal/Proxy_Iterator.h (Proxy_Iterator): + Switch to R_xlen_t ('clang++-17 -Wconversion -Wno-sign-conversion') + * inst/include/Rcpp/DataFrame.h: Idem + * inst/include/Rcpp/Vector.h: Idem + +2024-05-28 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2024-05-27 Dirk Eddelbuettel + + * README.md: Remove link references to StackOverflow + * inst/NEWS.Rd: Idem + * inst/include/Rcpp/Module.h (S4_CppOverloadedMethods): Add cast to int + to avoid warnings under 'clang++-17 -Wconversion -Wno-sign-conversion' + * inst/include/Rcpp/vector/Vector.h (Vector): Idem + * inst/include/Rcpp/module/class.h: Switch variable to size_t to avoid + to avoid warnings under 'clang++-17 -Wconversion -Wno-sign-conversion' + * inst/tinytest/testRcppClass/src/init.c: Add void to signature + +2024-05-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2024-05-23 Andrew Johnson + + * inst/include/Rcpp/: Added variadic templates to be used instead of + the generated code in `Rcpp/generated` and `Rcpp/module` when + compiling with C++11 or later. + +2024-05-18 Dirk Eddelbuettel + + * docker/ci-4.3/Dockerfile: Add rcpp/ci-4.3 container for R 4.3.* + * .github/workflows/ci.yaml (jobs): Add rcpp/ci-4.3 to matrix + +2024-05-16 Dirk Eddelbuettel + + * README.md: Use tinyverse.netlify.app for dependency badge + +2024-03-05 Dirk Eddelbuettel + + * docker/ci/Dockerfile: Switch the base container to r2u + * docker/plus/Dockerfile: Given r2u, install more binaries + + * README.md: Add r-universe badge + +2024-02-21 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * inst/include/Rcpp/r/headers.h: Set R_NO_REMAP (and MAXELTSIZE) + only if not already defined (as will be needed with R 4.4.0) + +2024-01-09 Dirk Eddelbuettel + + * README.md: Update usage numbers + + * README.md: Remove StackOverflow badge which only works for + logged-in users and is unsuitable for the README + +2024-01-08 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.12 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + +2024-01-01 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Updated to current versions of cited packages + * inst/bib/Rcpp.bib: Idem + +2023-12-27 Dirk Eddelbuettel + + * src/api.cpp (type2name): Refine OBJSXP return + +2023-12-21 Dirk Eddelbuettel + + * src/api.cpp (type2name): Recognise OBJSXP added in R 4.4.0 + +2023-11-28 Dirk Eddelbuettel + + * inst/tinytest/testRcppInterfaceExporter/R/RcppExports.R: Regenerated + * inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp: Idem + +2023-11-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * src/attributes.cpp (generateCpp): Add a format string for Rf_error + call to not run afoul of -Wformat-security + +2023-11-24 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * inst/include/Rcpp/iostream/Rstreambuf.h: Cast streamsize to int in + two spots + * inst/include/Rcpp/print.h (warningcall): Add missing '%s' format + +2023-11-11 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-FAQ.Rmd: Updated and edited + * vignettes/pdf/Rcpp-FAQ.pdf: Updated + * vignettes/rmd/Rcpp.bib: Updated + +2023-10-28 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-FAQ.Rmd: Updated and edited + * vignettes/pdf/Rcpp-FAQ.pdf: Updated + * vignettes/rmd/Rcpp.bib: Updated + +2023-10-27 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * R/tools.R: Correct missing Rd macros (spotted by R-devel CMD check) + +2023-10-22 Aaron Lun + + * inst/include/Rcpp/vector/MatrixColumn.h: Cast integer index + to R_xlen_t to avoid integer overflow with large matrices. + * inst/include/Rcpp/vector/MatrixRow.h: Ditto. + * inst/include/Rcpp/vector/Vector.h: Remove stray cast to int + that causes overflow when returning the end iterator. + +2023-09-30 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-introduction.Rmd (Rcpp): Correct caption of + third figure (cf GitHub issue #1276) + * vignettes/pdf/Rcpp-introduction.pdf: Rebuilt + +2023-08-31 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2023-08-29 Iñaki Ucar + + * R/Attributes.R: Ad-hoc fix for testthat's C entrypoint in + RcppExports.cpp + +2023-08-03 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2023-08-03 Michael Chirico + + * src/attributes.cpp: Directly `#include ` for `std::endl` + * src/date.cpp: Directly `#include ` for `TRUE` and + `FALSE` + +2023-07-03 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.11 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + +2023-07-02 Dirk Eddelbuettel + + * README.md: Update usage numbers in Examples section + +2023-07-01 Dirk Eddelbuettel + + * docker/ci-dev/Dockerfile: Make 'rm' more robust as 'rm -f' + * docker/ci-4.2/Dockerfile: Add new container for R 4.2.3 + * .github/workflows/ci.yaml (jobs): Add entry for R 4.2.3 + +2023-06-12 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll micro version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * README.md: Two URL updates for appease R CMD check + + * DESCRIPTION (Encoding): Somewhat belated addition + +2023-04-18 Dirk Eddelbuettel + + * README.md: Use app.codecov.io as base for codecov link + +2023-04-12 Dirk Eddelbuettel + + * .github/workflows/ci.yaml: Simplified container use + +2023-03-27 Dirk Eddelbuettel + + * .github/workflows/stale.yaml: Roll to v8 + +2023-03-27 Iñaki Ucar + + * R/Attributes.R: Remove command quoting, not needed anymore for system2() + * inst/tinytest/test_xptr.R: Update copyright + +2023-03-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * inst/tinytest/test_stats.R: Revisit change from PR #1252; we now + use a slightly smaller tolerance to accomodate old and new value + + * inst/tinytest/test_sugar.R: Protect a small number of tests on NA + propagation from running on arm64/Darwin which requires special care + +2023-03-25 Iñaki Ucar + + * R/Attributes.R: Switch to system2 to be able to capture stderr on error + +2023-03-24 Dirk Eddelbuettel + + * docker/ci-dev/Dockerfile: During Debian freeze experimental repo is + renamed which leads to a hickup here so temporarily remove list file + +2023-03-24 Iñaki Ucar + + * inst/tinytest/test_xptr.R: Skip some tests on Windows + +2023-03-19 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * src/attributes.cpp (RExportsGenerator::writeEnd): Replace a pair of + apostrophes with backticks in generated .Call() statemente + +2023-02-07 Dirk Eddelbuettel + + * inst/tinytest/test_stats.R: Use more accurate value in R 4.3.0 + +2023-02-06 Dirk Eddelbuettel + + * inst/CITATION: Update to new format preferred by r-devel + +2023-02-02 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * inst/include/Rcpp/sugar/functions/sapply.h: Enable compilation + under C++20 (using clang++ and its C++ library) via invoke_result + +2023-01-29 Iñaki Ucar + + * inst/tinytest/test_xptr.R: Fix a couple of tests writing to stdout + +2023-01-24 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2023-01-24 Lukasz Laniewski-Wollk + + * R/RcppLdpath.R: CxxFlags() now quotes only non-standard paths on linux + +2023-01-22 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.10 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + +2023-01-08 Dirk Eddelbuettel + + * inst/include/Rcpp/String.h: Address clang++-14 conversion warning + * inst/include/Rcpp/sugar/functions/mean.h: Idem + * inst/include/Rcpp/vector/Vector.h: Idem + * src/attributes.cpp: Idem + * src/date.cpp: Idem + +2022-12-29 Dirk Eddelbuettel + + * .github/workflows/docker.yaml (jobs): Update several actions + +2022-12-26 Dirk Eddelbuettel + + * .github/workflows/stale.yaml (jobs): Update actions/stale@v6 + +2022-11-14 Dirk Eddelbuettel + + * .github/workflows/ci.yaml (jobs): Update to actions/checkout@v3 + +2022-10-27 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2022-10-27 Kevin Ushey + + * inst/tinytest/cpp/coerce.cpp: add coerce unit tests + * inst/tinytest/test_coerce.R: idem + +2022-10-25 Dirk Eddelbuettel + + * inst/include/Rcpp/internal/r_coerce.h (coerce_to_string): + Replace last remaining sprintf with snprintf + +2022-10-12 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * R/Attributes.R (sourceCpp): Protect path to binary from spaces + +2022-10-06 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * inst/tinytest/test_dataframe.R (test.DataFrame.PushZeroLength): Add + new test + * inst/tinytest/cpp/DataFrame.cpp (DataFrame_PushOnEmpty): C++ + support for new test + +2022-10-04 Dirk Eddelbuettel + + * inst/include/Rcpp/DataFrame.h (set_type_after_push): Allow zero-row + data.frame objects to be grown by push_{back,front}() + +2022-09-25 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + +2022-09-23 Kevin Ushey + + * R/Module.R: Force 'finalize' method to be materialized + +2022-09-20 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * R/Attributes.R: Support C++20, C++23 and C++2b (for experimental / + incomplete support) via new plugins + +2022-07-27 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2022-07-23 Iñaki Ucar + + * inst/include/Rcpp/r/headers.h: Unwind protection is enabled by default + unless `RCPP_NO_UNWIND_PROTECT` is defined (`RCPP_USE_UNWIND_PROTECT` is + not checked anymore and has no effect) + * inst/include/Rcpp/vector/Vector.h: Switch evaluation to `Rcpp_eval` + * R/Attributes.R: `[[Rcpp::plugins(unwindProtect)]]` is deprecated + * inst/tinytest/cpp/stack.cpp: Adapted + * inst/tinytest/test_exceptions.R: Adapted + * inst/tinytest/test_interface.R: Adapted + * inst/tinytest/testRcppInterfaceExporter/src/config.h: Removed + +2022-07-10 Dirk Eddelbuettel + + * docker/ci-4.1/Dockerfile: Add Dockerfile for 4.1 series + * .github/workflows/ci.yaml: Add 4.1 to CI matrix + * .github/workflows/docker.yaml: Do not rebuild versioned ones + +2022-07-02 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.9 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + +2022-07-01 Dirk Eddelbuettel + + * man/dependsAttribute.Rd: Use https in URL + * man/exportAttribute.Rd: Idem + * man/interfacesAttribute.Rd: Idem + * DESCRIPTION (URL): Idem + * README.md: Idem, use Amazon page for Rcpp book + +2022-05-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2022-05-25 Dirk Eddelbuettel + + * inst/tinytest/test_string.R: Add C++11 conditioning for new unit tests + +2022-05-23 Dean Scarff + + * inst/include/Rcpp/String.h: Make less copies of strings via move + semantics and preserving the buffer/SEXP representation when copying + * inst/include/RcppCommon.h: include for std::move + * inst/tinytest/cpp/String.cpp: Add unit tests + * inst/tinytest/test_string.R: Add unit tests + +2022-05-12 Dirk Eddelbuettel + + * docker/ci/Dockerfile: Added xml2, also use more r-cran-* binaries + +2022-05-12 Marco Colombo + + * vignettes/rmd/Rcpp-FAQ.Rmd: Fixed typo + +2022-04-03 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-FAQ.Rmd: Add paragraph about Date(time) not + being aimed at parsing large quantities at once + * vignettes/pdf/Rcpp-FAQ.pdf: Idem + + * vignettes/rmd/Rcpp.bib: Add four entries + * inst/bib/Rcpp.bib: Idem + +2022-03-14 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2022-03-13 Iñaki Ucar + + * src/barrier.cpp: Untag tokens upon removal from the precious list, + so that the internal reference counter can be safely decremented by R + +2022-03-13 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * tests/tinytest.R: Disable full tests on four-digits release to not + exceed CRAN test time preference + +2022-03-10 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/tinytest/cpp/sugar.cpp: Also conditionally replace + std::unary_function with std::function + * vignettes/rmd/Rcpp-sugar.Rmd: Replace std::unary_function example + with std::function (implicitly requiring C++ in vignette example) + * vignettes/rmd/Rcpp-FAQ.Rmd: Idem + +2022-03-09 Dirk Eddelbuettel + + * inst/include/Rcpp/Language.h: To quieten compilations, replace + std::(unary|binary)_function with std::function for C++11 or later + * inst/include/Rcpp/StringTransformer.he: Idem + +2022-01-21 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2022-01-20 Dirk Eddelbuettel + + * src/attributes.cpp: Make three small changes to permit compilation + under C++98 now (while we consider just turning to C++11 overall) + +2022-01-14 Dirk Eddelbuettel + + * inst/tinytest/test_packageversion.R: Comparison to 'dev' revision + version now tolerant of optional trailing zero (e.g. 1.0.8.0) + +2022-01-11 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.8 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + + * inst/include/Rcpp/r/headers.h: STRICT_R_HEADERS set by default + unless override RCPP_NO_STRICT_HEADERS is set (cf issue #1158) + +2022-01-10 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Updated CRAN and R references + * inst/bib/Rcpp.bib: Idem + * vignettes/rmd/getCurrentVersionsOfCitedPackages.R: Updated + +2022-01-01 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * inst/NEWS.Rd: Added entries for a few PRs since last release + + * vignettes/rmd/Rcpp.bib: Provide both url and doi entries + * inst/bib/Rcpp.bib: Idem + +2021-12-28 Dirk Eddelbuettel + + * README.md: Add section on performance + +2021-12-24 Dirk Eddelbuettel + + * README.md: Update usage counts + +2021-12-16 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Update JSS references to new doi scheme, + update http URL links to https + * inst/bib/Rcpp.bib: Idem + +2021-12-10 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2021-12-08 Dirk Eddelbuettel + + * inst/include/Rcpp/Rcpp: Added as new entry point + * inst/include/Rcpp/Light: Added as lighter-weight entry point + * inst/include/Rcpp/Lighter: Idem + * inst/include/Rcpp/Lightest: Idem + +2021-11-30 Dirk Eddelbuettel + + * README.md: Remove Travis badge + * .travis.yml: Removed + +2021-11-15 Dirk Eddelbuettel + + * docker/ci/Dockerfile: Minor cleanup + +2021-11-14 Dirk Eddelbuettel + + * R/RcppLdpath.R: Simplified as we no longer need to worry about CXX0X + +2021-11-11 Kevin Ushey + + * R/RcppLdpath.R: CxxFlags() now quotes its include path + +2021-10-15 Travers Ching + + * inst/tinytest/testRcppAttributePackage: Tests `signature` attribute + * inst/tinytest/test_attribute_package.R: Tests `signature` attribute + +2021-10-13 Dirk Eddelbuettel + + * README.md: Switch JSS url to doi form per JSS request + * man/Rcpp-package.Rd: Idem + * man/RcppLdFlags.Rd: Idem + * inst/CITATION: Only use doi entries in three citEntry blocks + +2021-10-11 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * .codecov.yml (comment): Disable codecov comments on PRs + +2021-10-10 Travers Ching + + * src/attributes.cpp: Add `signature` attribute and syntax checks + +2021-10-02 Dirk Eddelbuettel + + * .github/workflows/docker.yaml (jobs): Add container builder action + +2021-10-01 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/NEWS.Rd: Updated + +2021-09-29 Iñaki Ucar + + * inst/include/Rcpp/XPtr.h: Check for new define + `RCPP_USE_FINALIZE_ON_EXIT` to flip the value of XPtr's `finalizeOnExit` + parameter from false (default) to true. + * inst/tinytest/test_xptr.R: Added test for this functionality. + +2021-09-27 Dirk Eddelbuettel + + * README.md: Added total downloads badge + +2021-09-06 Dirk Eddelbuettel + + * docker/ci-4.0/Dockerfile: Using R 4.0.5 to build ci-4.0 + * .github/workflows/ci.yaml (jobs): Also run against R 4.0.* + +2021-09-05 Dirk Eddelbuettel + + * inst/examples/Misc/piSugar.cpp (piSugar): Remove spurious call to + RNGScope we do not need with Rcpp Attributes + * inst/examples/RcppGibbs/RcppGibbs.R (Rgibbs): Comment on two uses + of RNGScope as historical in pre-Attributes code + * inst/examples/RcppGibbs/timeRNGs.R: Idem for one more + +2021-08-05 Dirk Eddelbuettel + + * inst/bib/Rcpp.bib: Use https for CRAN URLs + * vignettes/rmd/Rcpp.bib: Idem + +2021-07-25 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2021-07-24 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-FAQ.Rmd: New entry on growing vectors + +2021-07-08 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * cleanup: Check for optional vignettes/rmd before trying to access it + +2021-07-06 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.7 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/pdf/*: Rebuilt + +2021-07-05 Iñaki Ucar + + * src/barrier.cpp (Rcpp_precious_remove): Protect from call with + wrong token when unloading modules compiled under earlier version + +2021-07-02 Dirk Eddelbuettel + + * inst/include/Rcpp/r/headers.h: Update notice as January 2022 + release will remove protection for STRICT_R_HEADERS making it default + +2021-05-27 Dirk Eddelbuettel + + * inst/tinytest/cpp/rcppversion.cpp (checkVersion): Allow for more + than four components of a development version number + * inst/tinytest/test_packageversion.R: Idem + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Clarify in comment + +2021-05-13 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2021-05-09 Dirk Eddelbuettel + + * inst/include/RcppCommon.h: Add cfloat header + +2021-04-09 Dirk Eddelbuettel + + * inst/include/Rcpp/hash/IndexHash.h: Silence one comparison, update + use of unsigned int to uint32_t throughout + +2021-03-22 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2021-03-21 Dirk Eddelbuettel + + * inst/include/Rcpp/api/meat/message.h: Add wrapper for base::message + * inst/include/Rcpp/api/meat/meat.h: Include new file + * inst/tinytest/test_misc.R: Simple test + * inst/tinytest/cpp/misc.cpp (messageWrapper): Test support + +2021-02-23 Dirk Eddelbuettel + + * Contributing.md: Update unit test link to tinytest + +2021-02-08 Dirk Eddelbuettel + + * DESCRIPTION (Author): Add Inaki to the team + +2021-02-01 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * README.md: Mention the Rcpp drap repo and its release candidates in + installation section + +2021-01-30 Iñaki Ucar + + * inst/include/test_global_rostream.R: Added test new (optionally) + global Rcout and Rcerr objects + +2021-01-28 Iñaki Ucar + + * inst/include/Rcpp/iostream/Rstreambuf.h: Support for global + Rcout/Rcerr by defining `-DRCPP_USE_GLOBAL_ROSTREAM`; this mimics + std::cout/cerr; initialization code is automatically generated. + * inst/include/Rcpp/routines.h: Ditto + * src/api.cpp: Ditto + * src/attributes.cpp: Ditto + * src/rcpp_init.cpp: Ditto + +2021-01-21 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/DataFrame.h: Remove unused variable + + * R/Attributes.R (sourceCpp): Support argument echo to be passed to + source() to silence optional R evaluation + +2021-01-19 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/include/RcppCommon.h: Preverse existing API and offer new + token-based API alongside via Rcpp_Precious{Preserve,Release} + * inst/include/Rcpp/String.h: Use Rcpp_Precious{Preserve,Release} + * inst/include/Rcpp/storage/PreserveStorage.h: Ditto + +2021-01-17 Iñaki Ucar + + * inst/include/Rcpp/String.h: Use Rcpp_{Preserve,Release}Object + throughout which connects to Rcpp_precious_* routines + * inst/include/Rcpp/exceptions.h: Use Rcpp_ReleaseObject + * inst/include/Rcpp/routines.h: Several corrections and refinements + * inst/include/Rcpp/storage/PreserveStorage.h: Ditto + * inst/include/Rcpp/traits/named_object.h: Ditto + * inst/include/Rcpp/unwuindProtect.h: Ditto + * inst/include/RcppCommon.h: Ditto + * src/barrier.cpp: Ditto + +2021-01-17 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + [ these were originally committed 17 May 2020 and have been rebased ] + * src/barrier.cpp: Implement Rcpp_precious_{init,teardown,preserve,remove} + * src/rcpp_init.c: Register cpp_precious_{init,teardown,preserve,remove} + and call from R_{init,unload}_Rcpp + * inst/include/Rcpp/routines.h: Declare Rcpp_precious_{init,teardown, + preserve,remove} + * inst/include/Rcpp/exceptions.h: Use Rcpp_precious_remove + * inst/include/Rcpp/traits/named_object.h: Use + Rcpp_precious_{preserve,remove} + * inst/include/Rcpp/unwuindProtect.h: Use Rcpp_precious_preserve + * inst/include/RcppCommon.h: Use Rcpp_precious_{preserve,remove} + +2021-01-16 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * tests/tinytest.R: Test for CODECOV when deciding to run extensive + tests or just a subset, and set CI=true to enable run full set + + * .github/workflows/stale.yaml: Run weekly instead of daily + + * src/attributes.cpp: Additional #nocov tag(s) + * R/Attributes.R: Idem + * R/Module.R: Idem + * R/Rcpp.package.skeleton.R: Idem + * R/RcppClass.R: Idem + * R/RcppLdpath.R: Idem + + * src/attributes.cpp: Support include files with dots in package name + +2021-01-14 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.6 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + +2021-01-13 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Updated package versions + * inst/bib/Rcpp.bib: Idem + +2021-01-02 Dirk Eddelbuettel + + * R/Rcpp.package.skeleton.R: Wrap any() around grepl() + +2020-12-22 Dirk Eddelbuettel + + * .github/workflows/stale.yaml: Adding a staleness monitor labeling + and ultimately closing issues and PRs after suitably long windows + +2020-12-16 Dirk Eddelbuettel + + * inst/NEWS.Rd: Updated for recent activity + + * .github/workflows/ci.yaml: Add container-based CI runner + * README.md: Add new badge + +2020-11-06 Dirk Eddelbuettel + + * DESCRIPTION: More URL updates, e.g. http -> https + * README.md: Ditto + * inst/CITATION: Ditto + * man/Rcpp-package.Rd: Ditto + + * inst/CITATION: Change from PeerJ Preprint to TAS + +2020-10-25 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/generated/InternalFunction__ctors.h: Switch XPtr + finalizer argument from false to true + +2020-10-22 Dirk Eddelbuettel + + * inst/include/Rcpp/lang.h: Remove spurious whitespace + + * vignettes/.gitignore: Refined to no longer ignore pdf files + * vignettes/pdf/*: Added + + * inst/NEWS.Rd: Updated for two PRs + +2020-10-21 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-10-19 Benjamin Christoffersen + + * src/attributes.cpp: Initialize two private bool variable in default + constructor to avoid santizer warning + +2020-08-20 Mattias Ellert + + * inst/include/Rcpp/lang.h: Remove obsolete and confusing comment + +2020-08-05 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-07-09 Walter Somerville + + * inst/include/Rcpp/DataFrame.h: Warn when data.frame has varying + length + * inst/tinyTest/cpp/DataFrame.cpp: Test added + * inst/tinyTest/test_dataframe.R: Idem + +2020-07-07 Walter Somerville + + * inst/include/Rcpp/DataFrame.h: Implement explict push_back and + push_front for DataFrame, which takes care to set the class and + row.names attributes. + * inst/tinyTest/test_dataframe.R: Add in tests for + push_back/push_front + * inst/tinyTest/cpp/DataFrame.cpp: Idem + +2020-07-06 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-07-06 Kevin Ushey + + * inst/include/Rcpp/module/class.h: EXTPTR_PTR -> R_ExternalPtrAddr + * src/api.cpp: Idem + * src/module.cpp: Idem + +2020-07-01 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.5 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + +2020-06-27 Dirk Eddelbuettel + + * docker/ci/Dockerfile: Revert back to standard r-base container + * docker/plus/Dockerfile: Also install bit64 + +2020-06-19 Dirk Eddelbuettel + + * .travis.yml: Determine package name and version from DESCRIPTION, + switch to bionic + +2020-06-14 Dirk Eddelbuettel + + * inst/bib/Rcpp.bib: Add John's new 'S, R, and Data Science' article + * vignettes/rmd/Rcpp.bib: Idem + +2020-06-07 Dirk Eddelbuettel + + * .travis.yml (jobs): Replace R 3.4.3 with R 3.6.3 in matrix + +2020-06-05 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * R/Rcpp.package.skeleton.R: Remove a remaining NAMESPACE entry for + a temporary function symbol; ensure an exportPattern is set + +2020-05-18 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-05-17 Kevin Ushey + + * inst/include/Rcpp/String.h: Don't preserve returned SEXP in wrap + * inst/include/RcppCommon.h: Simplify + +2020-04-30 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * vignettes/rmd/Rcpp-libraries.Rmd: Add new vignette source + * vignettes/rmd/Rcpp.bib: Complete references + * inst/bib/Rcpp.bib: Idem + +2020-04-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-04-25 Dirk Eddelbuettel + + * inst/include/Rcpp/sugar/functions/sample.h: Replace R_alloc() with + a standard vector allocation to reduce memory consumption in sample + + * docker/ci/Dockerfile: Update for R 4.0.0 (with a temporary + diversion to rocker/r-base:4.0.0, and all-source installations) + + * vignettes/rmd/Makefile: Add bibtex call to JSS 2011 paper builds + +2020-04-16 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-04-15 Kevin Ushey + + * inst/include/Rcpp/String.h: Avoid 'debug' namespace collisions + * inst/include/Rcpp/macros/debug.h: Idem + * inst/include/Rcpp/macros/macros.h: Idem + +2020-04-15 Uwe Korn + + * inst/include/Rcpp/DataFrame.h: Explicit call to scalar std::abs + +2020-04-11 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-04-10 Kevin Ushey + + * inst/include/Rcpp/macros/macros.h: Safer definition of short_file_name + * inst/include/Rcpp/String.h: Idem + * inst/include/Rcpp/macros/debug.h: Idem + * src/api.cpp: Idem + +2020-04-10 Dirk Eddelbuettel + + * inst/tinytest/test_exceptions.R: Skip parts of file if on Solaris + +2020-04-02 Dirk Eddelbuettel + + * inst/NEWS.rd: Mark as patch release 1.0.4.6 + + * inst/tinytest/test_exceptions.R: If running skip remainder of file + on Windows to not trigger failed test + +2020-04-01 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2020-03-31 Dirk Eddelbuettel + + * docker/ci-dev/Dockerfile: Also install the 'codetools' package + +2020-03-31 Kevin Ushey + + * R/Attributes.R: Fix for sourceCpp() on Windows w/R-devel + +2020-03-28 Dirk Eddelbuettel + + * inst/examples/RcppGibbs/RcppGibbs_Updated.R: Updated example + +2020-03-24 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/Environment.h: Added two Shield wrappers + around Rf_langX calls + +2020-03-23 Dirk Eddelbuettel + + * .travis.yml (script): Run coverage as parallel step + +2020-03-22 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * docker/ci-3.4/Dockerfile: Added + * docker/ci-3.5/Dockerfile: Idem + * docker/ci-dev/Dockerfile: Idem + + * .travis.yml (jobs): Expand to matrix + +2020-03-22 Mattias Ellert + + * inst/include/Rcpp/exceptions_impl.h: Add include guard, + Make sure RCPP_DEMANGLER_ENABLED is always defined, + Add missing inline qualifier + +2020-03-18 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/include/Rcpp/lang.h: Define Rcpp_list{2,3,4,5} in the Rcpp + namespace + + * DESCRIPTION: Remove versioned depends on R (>= 3.0.0) from 2013 + +2020-03-17 Davis Vaughan + + * inst/include/Rcpp/lang.h: Inline Rcpp_list6() to support R 3.3. + +2020-03-17 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version (twice) + * inst/include/Rcpp/config.h: Idem + + * inst/NEWS.Rd: Updated + +2020-03-15 Kevin Ushey + + * inst/include/Rcpp/exceptions_impl.h: Ensure is included + into global namespace; refactor detection of demangler support + +2020-03-13 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.4 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * vignettes/rmd/Rcpp.bib: Idem + * inst/bib/Rcpp.bib: Idem + +2020-03-12 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp.bib: Updated to current package versions + * inst/bib/Rcpp.bib: Idem + +2020-02-24 Dirk Eddelbuettel + + * inst/include/Rcpp/exceptions_impl.h: Remove spurious semicolon + +2020-02-23 Dirk Eddelbuettel + + * inst/include/Rcpp/generated/Vector__create.h: Added #nocov tags + * inst/include/Rcpp/exceptions_impl.h: Idem + * src/api.cpp: Idem plus some whitespace realignment + +2020-02-13 Dirk Eddelbuettel + + * README.md: Add a Debian badge + +2020-02-12 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * README.md: Added indirect CRAN use badge + +2020-02-09 Joshua Pritikin + + * inst/include/Rcpp.h: Include exceptions_impl.h + * inst/include/Rcpp/exceptions.h: Make thread-safe + * inst/include/Rcpp/exceptions_impl.h: New home for code moved + from src/api.cpp + +2020-01-05 Dirk Eddelbuettel + + * inst/include/Rcpp/exceptions.h: A few more #nocov tags + * inst/include/Rcpp/generated/Vector__create.h: Idem, plus whitespace + +2020-01-04 Dirk Eddelbuettel + + * R/Attributes.R: A few more #nocov tags + +2020-01-01 Dirk Eddelbuettel + + * inst/include/Rcpp/module/Module.h: A few more #nocov tags + * inst/include/Rcpp/XPtr.h: Idem + * inst/include/Rcpp/vector/Vector.h: Idem + +2019-12-31 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2019-12-29 Qiang Kou + + * inst/include/Rcpp/vector/Matrix.h: Ensure scalar OP matrix do not + change right-hand side in operation + * inst/tinytest/test_matrix.R: New tests + * inst/tinytest/cpp/Matrix.cpp: Idem + +2019-12-20 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2019-12-18 Dirk Eddelbuettel + + * inst/include/Rcpp/XPtr.h: Additional null check, refactored + +2019-12-17 Kirill Müller + + * inst/include/Rcpp/XPtr.h: Clear external pointer before finalizer + +2019-12-17 Dirk Eddelbuettel + + * R/Attributes.R (sourceCpp): Very minor cosmetic changes + +2019-12-15 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2019-12-14 Dirk Eddelbuettel + + * R/Attributes.R (sourceCpp): Support new argument windowsDebugDLL to + create a debug DLL, supported on Windows only + * man/sourceCpp.Rd: Document it + + * src/date.cpp: A few more #nocov tage + +2019-12-13 Dirk Eddelbuettel + + * src/api.cpp: A few more #nocov tags + * src/attributes.cpp: Idem + * src/barrier.cpp: Idem + +2019-12-08 Dirk Eddelbuettel + + * tests/tinytest.R: Turn verbose tests on in dev and on Travis + + * inst/tinytest/test_client_package.R: Finer-grained skip messages + * inst/tinytest/test_module_client_package.R: Idem + * inst/tinytest/test_expose_class.R: Idem + * inst/tinytest/test_interface.R: Idem + * inst/tinytest/test_rcpp_package_skeleton.R: Idem + * inst/tinytest/test_reference.R: Idem + + * inst/tinytest/test_*.R: Streamlined initial test and sourceCpp call + + * src/attributes.cpp: Remove dangling '#nocov end' + +2019-12-07 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * inst/tinytest/test_binary_package.R: Finer-grained skip messages + + * inst/tinytest/test_misc.R: Add commented-out test that fails + * tests/tinytest.R: Minor edit + + * docker/ci/Dockerfile: Add curl and ssl -dev packages needed for covr + +2019-12-05 Dirk Eddelbuettel + + * vignettes/rmd/Rcpp-FAQ.Rmd (Rcpp): Add entry about "'dataptr' (or + 'enterRNGScope') not provided by Rcpp" recommending proper importFrom + +2019-12-03 Dirk Eddelbuettel + + * docker/ci/Dockerfile: Lighter builds as fewer Suggests: + * docker/plus/Dockerfile: Take packages moved from ci/Dockerfile + +2019-12-01 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + + * DESCRIPTION (Suggests): Remove knitr, rmarkdown, pinp + * DESCRIPTION (VignetteBuilder): Remove knitr + +2019-11-26 Dirk Eddelbuettel + + * inst/tinytest/test_embedded_r.R: Use sink to suppress noisy output, + reenable tests (still conditional on usual environment variable) + +2019-11-25 Dirk Eddelbuettel + + * inst/tinytest/cpp/Vector.cpp (no_op): Suppress compiler warning + +2019-11-24 Dirk Eddelbuettel + + * DESCRIPTION (Suggests): Add tinytest, remove RUnit + + * tests/doRUnit.R: Removed + * tests/tinytest.R: Added + + * tests/tinytest.R: Converted from RUnit to tinytest + * inst/tinytest/test_algorithm.R: Idem + * inst/tinytest/test_as.R: Idem + * inst/tinytest/test_binary_package.R: Idem (but inactive for now) + * inst/tinytest/test_client_package.R: Idem (but inactive for now) + * inst/tinytest/test_dataframe.R: Idem + * inst/tinytest/test_date.R: Idem (but condition two test sets on TZ) + * inst/tinytest/test_dispatch.R: Idem + * inst/tinytest/test_embedded.R: Idem + * inst/tinytest/test_environments.R: Idem + * inst/tinytest/test_exceptions.R: Idem + * inst/tinytest/test_exceptions_nocall.R: Idem + * inst/tinytest/test_expose_class.R: Idem + * inst/tinytest/test_function.R: Idem + * inst/tinytest/test_interface.R: Idem (but inactive for now) + * inst/tinytest/test_internal_function.R: Idem + * inst/tinytest/test_internal_function_cpp11.R: Idem + * inst/tinytest/test_language.R: Idem + * inst/tinytest/test_listof.R: Idem + * inst/tinytest/test_matrix.R: Idem + * inst/tinytest/test_misc.R: Idem + * inst/tinytest/test_modref.R: Idem + * inst/tinytest/test_module.R: Idem + * inst/tinytest/test_module_client_package.R: Idem + * inst/tinytest/test_na.R: Idem + * inst/tinytest/test_quickanddirty.R: Idem + * inst/tinytest/test_rcpp_package_skeleton.R: Idem + * inst/tinytest/test_reference.R: Idem + * inst/tinytest/test_rmath.R: Idem + * inst/tinytest/test_robject.R: Idem + * inst/tinytest/test_s4.R: Idem + * inst/tinytest/test_stack.R: Idem + * inst/tinytest/test_stats.R: Idem + * inst/tinytest/test_string.R: Idem + * inst/tinytest/test_subset.R: Idem + * inst/tinytest/test_sugar.R: Idem + * inst/tinytest/test_sugar_var.R: Idem + * inst/tinytest/test_support.R: Idem + * inst/tinytest/test_system.R: Idem + * inst/tinytest/test_table.R: Idem + * inst/tinytest/test_vector.R: Idem + * inst/tinytest/test_vector_old.R: Idem + * inst/tinytest/test_wrap.R: Idem + * inst/tinytest/test_wstring.R: Idem + * inst/tinytest/test_xptr.R: Idem + + * inst/tinytest/cpp/*: C++ support files for tests + * inst/tinytest/*: Other support files and directories from unitTests + + * R/unitTests.R: Removed as tied to RUnit setuo + + * inst/tinytest/test_attributes.R: Added test for error with + non-existing package in cppFunction + +2019-11-23 Dirk Eddelbuettel + + * docker/ci/Dockerfile: Add tinytest to ci Docker image + +2019-11-20 Dirk Eddelbuettel + + * R/Attributes.R: Test for and report unavailable 'LinkingTo' package + +2019-11-19 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + * inst/include/Rcpp/config.h: Idem + +2019-11-18 Kun Ren + + * src/attributes.cpp: Add invisible param to export attribute (#1024) + * vignettes/rmd/Rcpp-attributes.Rmd: Add an section of Returning + invisible object + +2019-11-13 Dirk Eddelbuettel + + * .github/ISSUE_TEMPLATE.md: Another small edit + * .github/PULL_REQUEST_TEMPLATE.md: Idem + +2019-11-13 Stephen Wade + + * inst/include/Rcpp/XPtr.h: Delete delegating ctor (follow-up #1012) + * inst/unitTests/runit.XPTr.R: Reinsert self-tag test on Windows + +2019-11-11 Dirk Eddelbuettel + + * inst/unitTests/runit.packageversion.R: New test + * inst/unitTests/cpp/rcppversion.cpp: Cpp portion of test + +2019-11-10 Dirk Eddelbuettel + + * .github/: Add files CONTRIBUTING.md, FUNDING.yml, ISSUE_TEMPLATE.md + and PULL_REQUEST_TEMPLATE.md + + * inst/include/Rcpp/config.h: Correct RCPP_VERSION and + RCPP_DEV_VERSION to 1.0.3 + +2019-11-09 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + +2019-11-09 TJ McKinley + + * R/Attributes.R: Correct how cppFunction() deals with multiple + depends arguments + +2019-11-08 Romain Francois + + * inst/include/Rcpp/lang.h: Safer Rcpp_list* and Rcpp_lang* + * inst/include/Rcpp/Function.h: Add Function.invoke() for operator() + * inst/include/Rcpp/generated/Function__operator.h: Safer + Function.operator() using Function.invoke() + +2019-11-08 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Release 1.0.3 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/Rcpp.bib: Idem + +2019-11-06 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * inst/include/Rcpp/XPtr.h: Provided fallback for old constructor + when C++11 is not available (follow-up to #1003) + * inst/unitTests/runit.XPTr.R (test.XPtr): On Windows (as a proxy for + old compilers) do not test new feature + + * tests/doRUnit.R: Protect printing to /tmp from Windows use + + * vignettes/rmd/Rcpp.bib: Updated + * inst/bib/Rcpp.bib: Idem + +2019-11-02 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * inst/include/Rcpp/Reference.h: Shield Rf_mkstring inside Rf_lang2 + * inst/include/Rcpp/Environment.h: Idem (inside Rf_lang4) + * inst/include/Rcpp/proxy/FieldProxy.h: Idem (inside Rf_lang3 and 4) + +2019-10-31 Romain Francois + + * inst/include/Rcpp/DataFrame.h: Protect temporaries from gc + * inst/include/Rcpp/Environment.h: Idem + * inst/include/Rcpp/r_cast.h: Idem + +2019-10-27 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * inst/unitTests/runit.exposeClass.R: Updated to pass with r-devel + + * vignettes/rmd/Rcpp-FAQ.Rmd: Two new short section on speedier + compilation and lack of exceptions / stop() across shared libraries + +2019-10-26 Dirk Eddelbuettel + + * vignettes/Rcpp-package.Rnw: Another wrapper + * vignettes/Rcpp-jss-2011.Rnw: Idem + + * vignettes/Makefile: Refinements + * vignettes/rmd/Makefile: Idem + + * cleanup: Removed bashism, added invocation of make clean + +2019-10-23 Dirk Eddelbuettel + + * vignettes/Rcpp-*.Rnw: Wrappers around pdf/*pdf + * vignettes/Makefile: Added + +2019-10-21 Dirk Eddelbuettel + + * vignettes/rmd/*: Moved from parent directory + * vignettes/pdf/*: New target directory + +2019-10-20 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * vignettes/Rcpp-FAQ.Rmd: Turn off knitr cache + * vignettes/Rcpp-introduction.Rmd: Idem + + * vignettes/Makefile: Add simple Makefile + * .Rbuildignore: Exclude vignettes/Makefile + +2019-10-19 Stephen Wade + + * inst/include/Rcpp/XPtr.h: XPtr constructor split up, a single + argument does not modify tags and protected data of the external pointer + * inst/unitTests/cpp/Xptr.cpp: Added test + * inst/unitTests/runit.XPtr.R: Idem + +2019-10-14 Dirk Eddelbuettel + + * README.md: Added CRAN + BioConductor badges for reverse depends, + +2019-10-11 Dirk Eddelbuettel + + * inst/include/Rcpp/exceptions.h: Condition use of typeid() on + absence of RCPP_NO_RTTI in two places + * inst/include/Rcpp/r/headers.h: RCPP_NO_RTTI implies RCPP_NO_MODULES + +2019-10-04 Dirk Eddelbuettel + + * vignettes/Rcpp-attributes.Rmd: Correct two unevaluated knitr C++ + chunks to mode 'Rcpp' rather than the (unregistered) C++ mode + * vignettes/Rcpp-extending.Rmd: Minor white-space tweak to avoid + paragraph-spacing warnings from latex and its mdframed style + * vignettes/Rcpp-modules.Rmd: Idem + * vignettes/Rcpp-sugar.Rmd: Idem + +2019-10-01 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + +2019-09-30 Kevin Ushey + + * inst/include/Rcpp.h: add RCPP_NO_MODULES + * inst/include/Rcpp/api/meat/is.h: Idem + * inst/include/Rcpp/api/meat/meat.h: Idem + +2019-09-28 Dirk Eddelbuettel + + * README.md: Add a stackoverflow tag to indicate where to ask questions, + also updated package counts on CRAN and BioC for Rcpp users + +2019-08-06 Riccardo Porreca + + * vignettes/Rcpp-modules.Rmd: Extensive review and edit improving the + Modules vignette + +2019-08-04 Dirk Eddelbuettel + + * README.md: Add thre doi badges + + * inst/NEWS.Rd: Two minor edits + +2019-07-21 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + +2019-07-21 Riccardo Porreca + + * R/Module.R: Use an explicit Rcpp:: in the initalize method for C++ + classes wrapped inside modules to ensure proper initialization + +2019-07-20 Dirk Eddelbuettel + + * DESCRIPTION: Release 1.0.2 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/Rcpp.bib: Idem + +2019-07-18 Pierrick Roger + + * src/attributes.cpp: Correct parsing of default function values + * inst/unitTests/cpp/attributes.cpp: Added tests + * inst/unitTests/runit.attributes.R: Idem + +2019-07-16 Dirk Eddelbuettel + + * debian/: Removed, see https://salsa.debian.org/edd/r-base/ instead + +2019-07-04 Dirk Eddelbuettel + + * vignettes/Rcpp.bib: Updated + * inst/bib/Rcpp.bib: Idem + +2019-05-05 Dirk Eddelbuettel + + * .Rbuildignore: Small tweak + +2019-04-27 Dirk Eddelbuettel + + * R/Rcpp.package.skeleton.R (Rcpp.package.skeleton): Use getRcppVersion() + +2019-04-26 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * R/tools.R (getRcppVersion): More idiomatic code + +2019-04-25 Dirk Eddelbuettel + + * R/tools.R (getRcppVersion): Export R (and dev) package version + * man/getRcppVersion.Rd: Documentation for new function + + * inst/include/Rcpp/config.h (RCPP_VERSION_STRING): New version + and development version string #define + * src/api.cpp (getRcppVersionStrings): Expose new versions strings + * src/internal.h: Register new version string exporter + * src/rcpp_init.cpp (callEntries[]): Idem + + * inst/unitTests/runit.misc.R (test.getRcppVersion): test new function + +2019-03-23 Ralf Stubner + + * vignettes/Rcpp-modules.Rmd: Describe RCPP_EXPOSED_* macros + * vignettes/Rcpp-extending.Rmd: Reference Modules extensions + +2019-03-23 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * inst/NEWS.Rd: Updated + +2019-03-20 James J Balamuta + + * inst/include/Rcpp/sugar/functions/unique.h: Added decreasing + parameter to control sort. + * inst/unitTests/runit.sugar.R: Added sort_unique() tests + * inst/unitTests/cpp/sugar.cpp: Ditto + +2019-03-20 Dirk Eddelbuettel + + * src/date.cpp: Renamed from Date.cpp + * src/module.cpp: Renamed from Module.cpp + * src/rcpp_init.cpp: Renamed from Rcpp_init.cpp + +2019-03-19 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * tests/doRUnit.R: On Travis always set RunAllRcppTests + + * docker/ci/Dockerfile: Set environment variables container-wide + +2019-03-18 Dirk Eddelbuettel + + * inst/include/Rcpp/macros/macros.h (END_RCPP_RETURN_ERROR): Add + UNPROTECT to reference nprot, also check for stop_sym + +2019-03-17 Dirk Eddelbuettel + + * DESCRIPTION: Release 1.0.1 + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/Rcpp.bib: Idem + +2019-03-16 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): Roll minor version + + * inst/unitTests/runit.sugar.R: Set the sample() behaviour to R 3.5.0 + as R 3.6.0 has a breaking change (for the better) + +2019-03-13 Romain François + + * inst/include/Rcpp/macros/macros.h: Add UNPROTECT to please rchk + +2019-03-12 Romain François + + * inst/include/Rcpp/api/meat/proxy.h: AttributeProxy::set() with + Shield<> and a few related uses of Shield<> to please rchk + * inst/include/Rcpp/clone.h: Idem + * inst/include/Rcpp/proxy/AttributeProxy.h: Idem + * inst/include/Rcpp/proxy/NamesProxy.h: Idem + * inst/include/Rcpp/vector/Matrix.h: Idem + * inst/include/Rcpp/vector/Vector.h: Idem + +2019-02-25 Dirk Eddelbuettel + + * .travis.yml (after_success): Setting CODECOV_TOKEN to reenable + codecov.io coverage as detailed by Ralf in GitHub issue #941 + +2019-02-16 Dirk Eddelbuettel + + * inst/include/Rcpp/sugar/functions/cbind.h: Converted CRLF to CR + +2019-02-15 Dirk Eddelbuettel + + * inst/README: Moved stale file to local/ + * inst/THANKS: Idem + +2019-02-13 Dirk Eddelbuettel + + * DESCRIPTION (Version, Date): New minor version + +2019-02-11 Kevin Ushey + + * R/Attributes.R: better handle pre-existing RcppExports.cpp, + RcppExports.R when calling compileAttributes() + +2019-02-09 Ralf Stubner + + * Rcpp-modules.Rmd: Added example for .factory + +2019-01-31 Dirk Eddelbuettel + + * inst/include/Rcpp/protection/Shelter.h (Rcpp): Only increase + nprotected count if object is not NULL (suggested by Stepan Sindelar) + +2018-12-26 Zhuoer Dong + + * vignettes/Rcpp-quickref.Rmd: Fix three bugs: use `Named()`, define + `glob`, `glob.ls(TRUE)`. + +2018-12-01 Dirk Eddelbuettel + + * R/Attributes.R: Added new 'c++2a' plugin for '-std=c++2a' + compilation standard supported by g++ 8 or later + +2018-11-11 Dirk Eddelbuettel + + * inst/include/Rcpp/vector/Subsetter.h (check_indices): More + informative error message as suggested by KK + +2018-11-09 William Nolan + + * inst/include/Rcpp/vector/Subsetter.h: Fixed to use R_xlen_t instead + of int for indexing and added warning when indexing by IntegerVector + (only for large enough vectors) + +2018-11-05 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Version 1.0, and happy 10th birthday! + + * inst/include/Rcpp/config.h: Idem + * inst/NEWS.Rd: Idem + * inst/bib/Rcpp.bib: Idem + * vignettes/Rcpp.bib: Idem + +2018-11-04 Dirk Eddelbuettel + + * DESCRIPTION (Date, Version): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + + * README.md: Updated stated package and test numbers + +2018-10-25 Kevin Ushey + + * inst/include/Rcpp/String.h: Use Rf_mkCharLenCE() as appropriate + * inst/unitTests/cpp/String.cpp: Add unit tests + * inst/unitTests/runit.String.R: Add unit tests + 2018-10-12 Dirk Eddelbuettel - * DESCRIPTION (Date, Version): Roll minor version - * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + * DESCRIPTION (Date, Version): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem - * tests/doRUnit.R: Simplified to something similar to what - RcppArmadillo (and other packages) had for a while now + * tests/doRUnit.R: Simplified to something similar to what + RcppArmadillo (and other packages) had for a while now - * vignettes/Rcpp-unitTests.Rnw: Removed as less useful now + * vignettes/Rcpp-unitTests.Rnw: Removed as less useful now 2018-10-08 JJ Allaire - * R/Attributes.R: Sort the files scanned for attributes in the C locale - for stable output across systems. + * R/Attributes.R: Sort the files scanned for attributes in the C locale + for stable output across systems. 2018-10-07 Ralf Stubner * vignettes/Rcpp-extending.Rmd: Correct EXPORT to EXPOSED in displays - of the corresponding macro, and remove two spurious semicolons + of the corresponding macro, and remove two spurious semicolons 2018-10-02 Dirk Eddelbuettel - * DESCRIPTION (Date, Version): Roll minor version - * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem + * DESCRIPTION (Date, Version): Roll minor version + * inst/include/Rcpp/config.h (RCPP_DEV_VERSION): Idem 2018-10-02 Romain Francois - * inst/include/Rcpp/vector/Matrix.h: Init nrow in Matrix(no_init) ctor - * inst/unitTests/runit.Matrix.R: New test - * inst/unitTests/cpp/Matrix.cpp: Idem + * inst/include/Rcpp/vector/Matrix.h: Init nrow in Matrix(no_init) ctor + * inst/unitTests/runit.Matrix.R: New test + * inst/unitTests/cpp/Matrix.cpp: Idem 2018-09-30 Dirk Eddelbuettel - * man/RcppUnitTests.Rd: Remove \details{} with conditional code which - R-devel (as of Sep 28) warns about as empty + * man/RcppUnitTests.Rd: Remove \details{} with conditional code which + R-devel (as of Sep 28) warns about as empty 2018-09-28 Dirk Eddelbuettel - * .travis.yml (env): Set distinct build and check options to skip - tests of vignettes + * .travis.yml (env): Set distinct build and check options to skip + tests of vignettes 2018-09-27 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version - * inst/include/Rcpp/date_datetime/Date.h: Remove the empty destructor - to make g++-9 (prerelease) happy [CRAN request] + * inst/include/Rcpp/date_datetime/Date.h: Remove the empty destructor + to make g++-9 (prerelease) happy [CRAN request] - * inst/unitTests/runit.Matrix.R: Correct typo + * inst/unitTests/runit.Matrix.R: Correct typo 2018-09-27 Romain Francois - * inst/include/Rcpp/vector/Matrix.h: Fix Matrix(no_init(int,int)) - constructor - * inst/unitTests/runit.Matrix.R: test for above - * inst/unitTests/cpp/Matrix.cpp: same + * inst/include/Rcpp/vector/Matrix.h: Fix Matrix(no_init(int,int)) + constructor + * inst/unitTests/runit.Matrix.R: test for above + * inst/unitTests/cpp/Matrix.cpp: same 2018-09-26 Dirk Eddelbuettel - * docker/ci/Dockerfile: Set env var RunAllRcppTests=yes - * .travis.yml: Do not set env var here as needed in Docker + * docker/ci/Dockerfile: Set env var RunAllRcppTests=yes + * .travis.yml: Do not set env var here as needed in Docker 2018-09-21 Dirk Eddelbuettel @@ -68,95 +2454,95 @@ * vignettes/Rcpp.bib: Idem * inst/include/Rcpp/config.h: Idem - * R/RcppLdpath.R (RcppLdPath, RcppLdFlags, CxxFlags, RcppCxx0xFlags): - After discussion with CRAN, do not mark as .Deprecated() as too many - packages are involved. This will need to be phased in more slowly. + * R/RcppLdpath.R (RcppLdPath, RcppLdFlags, CxxFlags, RcppCxx0xFlags): + After discussion with CRAN, do not mark as .Deprecated() as too many + packages are involved. This will need to be phased in more slowly. 2018-09-20 Dirk Eddelbuettel - * vignettes/Rcpp-FAQ.Rmd: Set 'eval=FALSE' on another - RcppArmadillo example to not create a build-time dependency + * vignettes/Rcpp-FAQ.Rmd: Set 'eval=FALSE' on another + RcppArmadillo example to not create a build-time dependency 2018-09-18 JJ Allaire - * src/attributes.cpp: Add support for [[Rcpp::init]] attribute - * vignettes/Rcpp-attributes.Rmd: Documentation for [[Rcpp::init]] - attribute + * src/attributes.cpp: Add support for [[Rcpp::init]] attribute + * vignettes/Rcpp-attributes.Rmd: Documentation for [[Rcpp::init]] + attribute 2018-09-17 Dirk Eddelbuettel - * inst/include/Rcpp/r/headers.h: Define STRICT_R_HEADERS, but until - September 2019 protect by defining RCPP_NO_STRICT_HEADERS + * inst/include/Rcpp/r/headers.h: Define STRICT_R_HEADERS, but until + September 2019 protect by defining RCPP_NO_STRICT_HEADERS - * .travis.yml (env): Switch to rcpp/ci for ci use + * .travis.yml (env): Switch to rcpp/ci for ci use 2018-09-15 Dirk Eddelbuettel - * docker/ci/Dockerfile: Move Dockerfile to docker/ci - * docker/run/Dockerfile: Add deployment Dockerfile - * docker/plus/Dockerfile: Add 'plus-sized' Dockerfile suitable for - different add-on packages requiring Rcpp{Armadillo,Eigen,GSL} or BH + * docker/ci/Dockerfile: Move Dockerfile to docker/ci + * docker/run/Dockerfile: Add deployment Dockerfile + * docker/plus/Dockerfile: Add 'plus-sized' Dockerfile suitable for + different add-on packages requiring Rcpp{Armadillo,Eigen,GSL} or BH 2018-09-02 Dirk Eddelbuettel - * .travis.yml: Switch to rcpp/rcpp-testing container + * .travis.yml: Switch to rcpp/rcpp-testing container 2018-08-29 Dirk Eddelbuettel - * .travis.yml: Use Dockerfile + * .travis.yml: Use Dockerfile 2018-08-28 Dirk Eddelbuettel - * docker/Dockerfile: Add Dockerfile for use by Travis CI + * docker/Dockerfile: Add Dockerfile for use by Travis CI 2018-08-27 Dirk Eddelbuettel * DESCRIPTION (Version, Date): Roll minor version * inst/include/Rcpp/config.h: Idem - * man/Rcpp-deprecated.Rd: Fix two-char typo/thinko in \link{} + * man/Rcpp-deprecated.Rd: Fix two-char typo/thinko in \link{} 2018-07-29 Dirk Eddelbuettel - * README.md: Refreshed via some edits and updates + * README.md: Refreshed via some edits and updates * DESCRIPTION (Version, Date): Roll minor version * inst/include/Rcpp/config.h: Idem 2018-07-28 Dirk Eddelbuettel - * R/RcppLdpath.R (RcppLdPath, RcppLdFlags, CxxFlags, RcppLdFlags) - (RcppCxx0xFlags): Marked as deprecated + * R/RcppLdpath.R (RcppLdPath, RcppLdFlags, CxxFlags, RcppLdFlags) + (RcppCxx0xFlags): Marked as deprecated - * man/Rcpp-deprecated.Rd: Add exported functions LdFlags() and - RcppLdFlags() as deprecated - * man/RcppLdFlags.Rd: Idem + * man/Rcpp-deprecated.Rd: Add exported functions LdFlags() and + RcppLdFlags() as deprecated + * man/RcppLdFlags.Rd: Idem 2018-07-27 Dirk Eddelbuettel - * man/loadRcppModules-deprecated.Rd: Fix typo; was deprecated in - 0.12.5, not 0.16.5 which does not exist + * man/loadRcppModules-deprecated.Rd: Fix typo; was deprecated in + 0.12.5, not 0.16.5 which does not exist 2018-07-26 Dirk Eddelbuettel - * vignettes/Rcpp-FAQ.Rmd: Use collapse: true - * vignettes/Rcpp-introduction.Rmd: Idem + * vignettes/Rcpp-FAQ.Rmd: Use collapse: true + * vignettes/Rcpp-introduction.Rmd: Idem 2018-07-25 Dirk Eddelbuettel - * vignettes/Rcpp-extending.Rmd: Use collapse: true + * vignettes/Rcpp-extending.Rmd: Use collapse: true 2018-07-24 Martin Lysy * R/loadRcppClass.R: Search in R module for 'Class' instead of - 'CppClass'. + 'CppClass'. * R/exposeClass.R: Fixed 'rename' argument to work as expected. * inst/unitTests/runit.exposeClass.R: Added unit tests for the - above. + above. 2018-07-23 Dirk Eddelbuettel - * inst/bib/Rcpp.bib: More updates + * inst/bib/Rcpp.bib: More updates * vignettes/Rcpp.bib: Idem 2018-07-21 Dirk Eddelbuettel @@ -167,25 +2553,25 @@ * vignettes/Rcpp.bib: Idem * inst/include/Rcpp/config.h: Idem - * vignettes/Rcpp.bib: Updated other references - * inst/bib/Rcpp.bib: Idem + * vignettes/Rcpp.bib: Updated other references + * inst/bib/Rcpp.bib: Idem - * inst/unitTests/runit.sugar.R: Additional min, max unit tests - * inst/unitTests/cpp/sugar.cpp: Idem + * inst/unitTests/runit.sugar.R: Additional min, max unit tests + * inst/unitTests/cpp/sugar.cpp: Idem 2018-07-20 Dirk Eddelbuettel - * inst/include/Rcpp/sugar/functions/max.h: Also consider case of an - empty vector - * inst/include/Rcpp/sugar/functions/min.h: Idem + * inst/include/Rcpp/sugar/functions/max.h: Also consider case of an + empty vector + * inst/include/Rcpp/sugar/functions/min.h: Idem 2018-07-19 Jack Wasey * inst/include/Rcpp/r_cast.h: Error and abort if debugging for STRSXP 2018-07-24 Martin Lysy - * R/loadRcppClass.R: Search in R module for 'Class' instead of 'CppClass'. - * R/exposeClass.R: Fixed 'rename' argument to work as expected. - * inst/unitTests/runit.exposeClass.R: Added unit tests for the above. + * R/loadRcppClass.R: Search in R module for 'Class' instead of 'CppClass'. + * R/exposeClass.R: Fixed 'rename' argument to work as expected. + * inst/unitTests/runit.exposeClass.R: Added unit tests for the above. 2018-07-12 Dirk Eddelbuettel @@ -194,8 +2580,8 @@ 2018-07-12 Jack Wasey - * R/Attributes.R: Use case-insensitive sort of filenames to make - RcppExports more deterministic + * R/Attributes.R: Use case-insensitive sort of filenames to make + RcppExports more deterministic 2018-07-10 Lionel Henry @@ -208,8 +2594,8 @@ 2018-07-09 Dirk Eddelbuettel - * src/Date.cpp: Skip 'tm_gmtoff' on AIX as well (thanks to PR 876 - by @ayappanec) + * src/Date.cpp: Skip 'tm_gmtoff' on AIX as well (thanks to PR 876 + by @ayappanec) 2018-07-05 Lionel Henry diff --git a/Contributing.md b/Contributing.md index 2e7c94dd0..8c975175d 100644 --- a/Contributing.md +++ b/Contributing.md @@ -30,29 +30,33 @@ post an issue outlining some motivation for your pull request to ensure that some discussion around the appropriate resolution for the issue occurs first. We would prefer it if your PR also included -[unit tests](https://github.com/RcppCore/Rcpp/tree/master/inst/unitTests). Additions +[unit tests](https://github.com/RcppCore/Rcpp/tree/master/inst/tinytest). Additions 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 248bfc64d..4741fbb4b 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -1,25 +1,38 @@ Package: Rcpp Title: Seamless R and C++ Integration -Version: 0.12.19.3 -Date: 2018-10-12 -Author: Dirk Eddelbuettel, Romain Francois, JJ Allaire, Kevin Ushey, Qiang Kou, - Nathan Russell, Douglas Bates and John Chambers -Maintainer: Dirk Eddelbuettel +Version: 1.1.1.1 +Date: 2026-01-12 +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 code as well as easier integration of third-party libraries. Documentation about 'Rcpp' is provided by several vignettes included in this package, via the - 'Rcpp Gallery' site at , the paper by Eddelbuettel and + 'Rcpp Gallery' site at , the paper by Eddelbuettel and Francois (2011, ), the book by Eddelbuettel (2013, ) and the paper by Eddelbuettel and Balamuta (2018, ); see 'citation("Rcpp")' for details. -Depends: R (>= 3.0.0) +Depends: R (>= 3.5.0) Imports: methods, utils -Suggests: RUnit, inline, rbenchmark, knitr, rmarkdown, pinp, pkgKitten (>= 0.1.2) -VignetteBuilder: knitr -URL: http://www.rcpp.org, http://dirk.eddelbuettel.com/code/rcpp.html, https://github.com/RcppCore/Rcpp +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: Please send questions and comments regarding Rcpp to rcpp-devel@lists.r-forge.r-project.org -RoxygenNote: 6.0.1 +RoxygenNote: 6.1.1 +Encoding: UTF-8 +VignetteBuilder: Rcpp diff --git a/NAMESPACE b/NAMESPACE index 3e7ab64e0..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, @@ -32,8 +31,8 @@ export(Module, sizeof, cpp_object_initializer, cpp_object_dummy, - Rcpp.plugin.maker - ) + Rcpp.plugin.maker, + 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 15e6aae64..f34e83b17 100644 --- a/R/Attributes.R +++ b/R/Attributes.R @@ -1,5 +1,6 @@ -# Copyright (C) 2012 - 2017 JJ Allaire, Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2012 - 2022 JJ Allaire, Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2023 - 2026 JJ Allaire, Dirk Eddelbuettel, Romain Francois and Iñaki Ucar # # This file is part of Rcpp. # @@ -27,7 +28,9 @@ sourceCpp <- function(file = "", cleanupCacheDir = FALSE, showOutput = verbose, verbose = getOption("verbose"), - dryRun = FALSE) { + dryRun = FALSE, + windowsDebugDLL = FALSE, + echo = TRUE) { # use an architecture/version specific subdirectory of the cacheDir # (since cached dynlibs can now perist across sessions we need to be @@ -62,7 +65,15 @@ sourceCpp <- function(file = "", if (grepl(' ', basename(file), fixed=TRUE)) { stop("The filename '", basename(file), "' contains spaces. This ", "is not permitted.") - } # #nocov end + } + } else { + if (windowsDebugDLL) { + if (verbose) { + message("The 'windowsDebugDLL' toggle is ignored on ", + "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) @@ -74,7 +85,7 @@ sourceCpp <- function(file = "", # print output for verbose mode if (verbose) - .printVerboseOutput(context) + .printVerboseOutput(context) # #nocov # variables used to hold completed state (passed to completed hook) succeeded <- FALSE @@ -106,7 +117,7 @@ sourceCpp <- function(file = "", # on.exit handler calls hook and restores environment and working dir on.exit({ if (!succeeded) - .showBuildFailureDiagnostics() + .showBuildFailureDiagnostics() # #nocov .callBuildCompleteHook(succeeded, output) setwd(cwd) .restoreEnvironment(envRestore) @@ -118,22 +129,31 @@ sourceCpp <- function(file = "", file.remove(context$previousDynlibPath) } # #nocov end + # grab components we need to build command + r <- file.path(R.home("bin"), "R") + lib <- context$dynlibFilename + deps <- context$cppDependencySourcePaths + src <- context$cppSourceFilename + # prepare the command (output if we are in showOutput mode) - cmd <- paste(R.home(component="bin"), .Platform$file.sep, "R ", - "CMD SHLIB ", - "-o ", shQuote(context$dynlibFilename), " ", - ifelse(rebuild, "--preclean ", ""), - ifelse(dryRun, "--dry-run ", ""), - paste(shQuote(context$cppDependencySourcePaths), - collapse = " "), " ", - shQuote(context$cppSourceFilename), " ", - sep="") + args <- c( + "CMD", "SHLIB", + if (windowsDebugDLL) "-d", + if (rebuild) "--preclean", + if (dryRun) "--dry-run", + "-o", shQuote(lib), + if (length(deps)) + paste(shQuote(deps), collapse = " "), + shQuote(src) + ) + if (showOutput) - cat(cmd, "\n") + cat(paste(c(r, args), collapse = " "), "\n") # #nocov # execute the build -- suppressWarnings b/c when showOutput = FALSE # we are going to explicitly check for an error and print the output - result <- suppressWarnings(system(cmd, intern = !showOutput)) + so <- if (showOutput) "" else TRUE + result <- suppressWarnings(system2(r, args, stdout = so, stderr = so)) # check build results if(!showOutput) { @@ -166,14 +186,14 @@ sourceCpp <- function(file = "", on.exit({ setwd(cwd) }) - if (verbose) + if (verbose) # #nocov start cat("\nNo rebuild required (use rebuild = TRUE to ", "force a rebuild)\n\n", sep="") } # return immediately if this was a dry run if (dryRun) - return(invisible(NULL)) + return(invisible(NULL)) # #nocov end # load the module if we have exported symbols if (length(context$exportedFunctions) > 0 || length(context$modules) > 0) { @@ -196,12 +216,12 @@ sourceCpp <- function(file = "", if (embeddedR && (length(context$embeddedR) > 0)) { srcConn <- textConnection(context$embeddedR) setwd(rWorkingDir) # will be reset by previous on.exit handler - source(file = srcConn, local = env, echo = TRUE) + source(file = srcConn, local = env, echo = echo) } # cleanup the cache dir if requested if (cleanupCacheDir) - cleanupSourceCppCache(cacheDir, context$cppSourcePath, context$buildDirectory) + cleanupSourceCppCache(cacheDir, context$cppSourcePath, context$buildDirectory) # #nocov # return (invisibly) a list containing exported functions and modules invisible(list(functions = context$exportedFunctions, @@ -240,11 +260,12 @@ cppFunction <- function(code, rebuild = FALSE, cacheDir = getOption("rcpp.cache.dir", tempdir()), showOutput = verbose, - verbose = getOption("verbose")) { + verbose = getOption("verbose"), + echo = TRUE) { # process depends if (!is.null(depends) && length(depends) > 0) { # #nocov start - depends <- paste(depends, sep=", ") + depends <- paste(depends, collapse=", ") scaffolding <- paste("// [[Rcpp::depends(", depends, ")]]", sep="") scaffolding <- c(scaffolding, "", .linkingToIncludes(depends, FALSE), recursive=TRUE) # #nocov end @@ -285,25 +306,26 @@ cppFunction <- function(code, "\n--------------------------------------------------------\n\n") cat(code) cat("\n") - } # #nocov end + } # source cpp into specified environment. if env is set to NULL # then create a new one (the caller can get a hold of the function # via the return value) if (is.null(env)) - env <- new.env() + env <- new.env() # #nocov end exported <- sourceCpp(code = code, env = env, rebuild = rebuild, cacheDir = cacheDir, showOutput = showOutput, - verbose = verbose) + verbose = verbose, + echo = echo) # verify that a single function was exported and return it if (length(exported$functions) == 0) - stop("No function definition found") + stop("No function definition found") # #nocov else if (length(exported$functions) > 1) - stop("More than one function definition") + stop("More than one function definition") # #nocov else { functionName <- exported$functions[[1]] invisible(get(functionName, env)) @@ -395,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") + stop("pkgdir must refer to the directory containing an R package") # #nocov pkgDesc <- read.dcf(descFile)[1,] pkgname = .readPkgDescField(pkgDesc, "Package") depends <- c(.readPkgDescField(pkgDesc, "Depends", character()), @@ -407,23 +429,29 @@ 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") + stop("pkgdir must refer to the directory containing an R package") # #nocov pkgNamespace <- readLines(namespaceFile, warn = FALSE) registration <- any(grepl("^\\s*useDynLib.*\\.registration\\s*=\\s*TRUE.*$", pkgNamespace)) # determine source directory srcDir <- file.path(pkgdir, "src") if (!file.exists(srcDir)) - return (FALSE) + return (FALSE) # #nocov # create R directory if it doesn't already exist rDir <- file.path(pkgdir, "R") if (!file.exists(rDir)) - dir.create(rDir) + dir.create(rDir) # #nocov + + # remove the old RcppExports.R file + unlink(file.path(rDir, "RcppExports.R")) # get a list of all source files cppFiles <- list.files(srcDir, pattern = "\\.((c(c|pp)?)|(h(pp)?))$", ignore.case = TRUE) + # don't include RcppExports.cpp + cppFiles <- setdiff(cppFiles, "RcppExports.cpp") + # locale independent sort for stable output locale <- Sys.getlocale(category = "LC_COLLATE") Sys.setlocale(category = "LC_COLLATE", locale = "C") @@ -458,7 +486,7 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { pkgHeaderPath <- file.path(pkgdir, "src", pkgHeader) pkgHeader <- pkgHeader[file.exists(pkgHeaderPath)] if (length(pkgHeader) > 0) - includes <- c(paste0("#include \"", pkgHeader ,"\""), includes) + includes <- c(paste0("#include \"", pkgHeader ,"\""), includes) # #nocov # generate exports invisible(.Call("compileAttributes", PACKAGE="Rcpp", @@ -469,23 +497,13 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { # setup plugins environment .plugins <- new.env() -# built-in C++98 plugin +# 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 @@ -497,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 @@ -510,10 +525,31 @@ 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")) + list(env = list(USE_CXX17 = "yes")) +} + +# built-in C++20 plugin for C++20 +.plugins[["cpp20"]] <- function() { + if (getRversion() >= "4.2") # with recent R versions, R can decide + list(env = list(USE_CXX20 = "yes")) + else + list(env = list(PKG_CXXFLAGS ="-std=c++20")) +} + +# built-in C++23 plugin for C++23 +.plugins[["cpp23"]] <- function() { + if (getRversion() >= "4.3") # with recent R versions, R can decide + list(env = list(USE_CXX23 = "yes")) + else + 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++17")) + list(env = list(PKG_CXXFLAGS ="-std=c++26")) } ## built-in C++1z plugin for C++17 standard under development @@ -523,16 +559,93 @@ compileAttributes <- function(pkgdir = ".", verbose = getOption("verbose")) { list(env = list(PKG_CXXFLAGS ="-std=c++1z")) } -## built-in OpenMP plugin -.plugins[["openmp"]] <- function() { - list(env = list(PKG_CXXFLAGS="-fopenmp", - PKG_LIBS="-fopenmp")) +## built-in C++2a plugin for g++ 8 and later +## cf https://gcc.gnu.org/projects/cxx-status.html as of Dec 2018 +.plugins[["cpp2a"]] <- function() { + list(env = list(PKG_CXXFLAGS ="-std=c++2a")) } -.plugins[["unwindProtect"]] <- function() { - list(env = list(PKG_CPPFLAGS = "-DRCPP_USE_UNWIND_PROTECT")) +## built-in C++2b plugin for compilers without C++23 support +.plugins[["cpp2b"]] <- function() { + 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"]] <- if (Sys.info()[["sysname"]] == "Darwin") { + .openmpPluginDarwin +} else { + .openmpPluginDefault +} + +.plugins[["unwindProtect"]] <- function() { # nocov start + warning("unwindProtect is enabled by default and this plugin is deprecated.", + " It will be removed in a future version of Rcpp.") + list() +} # nocov end + # register a plugin registerPlugin <- function(name, plugin) { .plugins[[name]] <- plugin # #nocov @@ -616,7 +729,7 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { # Split the depends field of a package description .splitDepends <- function(x) { if (!length(x)) - return(character()) + return(character()) # #nocov x <- unlist(strsplit(x, ",")) x <- sub("[[:space:]]+$", "", x) x <- unique(sub("^[[:space:]]*(.*)", "\\1", x)) @@ -643,9 +756,9 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { plugin <- .plugins[[pluginName]] if (is.null(plugin)) - stop("Inline plugin '", pluginName, "' could not be found ", + stop("Inline plugin '", pluginName, "' could not be found ", # #nocov start "within the Rcpp package. You should be ", - "sure to call registerPlugin before using a plugin.") + "sure to call registerPlugin before using a plugin.") # #nocov end return(plugin) } @@ -671,7 +784,7 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { buildEnv[[name]] <<- value } # if it's not identical then append - else if (!identical(buildEnv[[name]], value)) { + else if (!identical(buildEnv[[name]], value)) { # #nocov buildEnv[[name]] <<- paste(buildEnv[[name]], value) # #nocov } else { @@ -853,7 +966,7 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { # variables to reset setVars <- restore[!is.na(restore)] if (length(setVars)) - do.call(Sys.setenv, setVars) + do.call(Sys.setenv, setVars) # #nocov # variables to remove removeVars <- names(restore[is.na(restore)]) @@ -912,7 +1025,7 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { .getHooksList <- function(name) { hooks <- getHook(name) if (!is.list(hooks)) - hooks <- list(hooks) + hooks <- list(hooks) # #nocov hooks } @@ -926,7 +1039,7 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { # This field can be NULL or empty -- in that case just return Rcpp.h if (is.null(linkingTo) || !nzchar(linkingTo)) - return (c("#include ")) + return (c("#include ")) # #nocov # Look for Rcpp inline plugins within the list or LinkedTo packages include.before <- character() @@ -950,6 +1063,11 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { # otherwise check for standard Rcpp::interfaces generated include else if (!pluginsOnly) { pkgPath <- find.package(package, NULL, quiet=TRUE) + if (length(pkgPath) == 0) { + stop(paste("Package '", package, "' referenced from ", + "LinkingTo directive is not available.", sep=""), + call. = FALSE) + } pkgHeader <- paste(package, ".h", sep="") pkgHeaderPath <- file.path(pkgPath, "include", pkgHeader) if (file.exists(pkgHeaderPath)) { @@ -1006,7 +1124,7 @@ sourceCppFunction <- function(func, isVoid, dll, symbol) { .parseLinkingTo <- function(linkingTo) { if (is.null(linkingTo)) - return (character()) + return (character()) # #nocov linkingTo <- strsplit(linkingTo, "\\s*\\,")[[1]] result <- gsub("\\s", "", linkingTo) @@ -1169,37 +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 - }) - for (match in matches) { - routine <- match[[2]] - if (!routine %in% routines) { - declaration <- grep(sprintf("^extern .* %s\\(.*$", routine), code, - value = TRUE) - declarations <- c(declarations, sub("^extern", "RcppExport", declaration)) - call_entries <- c(call_entries, match[[1]]) - } + # 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 95257d3ed..10c3cadce 100644 --- a/R/Module.R +++ b/R/Module.R @@ -1,4 +1,4 @@ -# Copyright (C) 2010 - 2016 John Chambers, Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2010 - 2026 John Chambers, Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -131,6 +131,8 @@ new_dummyObject <- function(...) # #nocov # class method for $initialize cpp_object_initializer <- function(.self, .refClassDef, ..., .object_pointer){ + # force finalize method to be materialized + invisible(.self$finalize) selfEnv <- as.environment(.self) ## generate the C++-side object and store its pointer, etc. ## access the private fields in the fieldPrototypes env. @@ -160,11 +162,11 @@ cpp_object_maker <- function(typeid, pointer){ } Module <- function( module, PACKAGE = methods::getPackageName(where), where = topenv(parent.frame()), mustStart = FALSE ) { - if(inherits(module, "DLLInfo") && missing(mustStart)) mustStart <- TRUE - if(inherits(module, "Module")) { + if (inherits(module, "DLLInfo") && missing(mustStart)) mustStart <- TRUE # #nocov + if (inherits(module, "Module")) { xp <- .getModulePointer(module, FALSE) if(!missing(PACKAGE)) - warning("ignoring PACKAGE argument in favor of internal package from Module object") + warning("ignoring PACKAGE argument in favor of internal package from Module object") # #nocov env <- as.environment(module) # not needed from R 2.12.0 PACKAGE <- get("packageName", envir = env) moduleName <- get("moduleName", envir = env) @@ -229,12 +231,12 @@ Module <- function( module, PACKAGE = methods::getPackageName(where), where = to # just to make codetools happy .self <- .refClassDef <- NULL generator$methods(initialize = - if(cpp_hasDefaultConstructor(CLASS)) - function(...) cpp_object_initializer(.self,.refClassDef, ...) + if (cpp_hasDefaultConstructor(CLASS)) + function(...) Rcpp::cpp_object_initializer(.self,.refClassDef, ...) else function(...) { - if(nargs()) cpp_object_initializer(.self,.refClassDef, ...) - else cpp_object_dummy(.self, .refClassDef) + if (nargs()) Rcpp::cpp_object_initializer(.self,.refClassDef, ...) + else Rcpp::cpp_object_dummy(.self, .refClassDef) # #nocov } ) rm( .self, .refClassDef ) diff --git a/R/Rcpp.package.skeleton.R b/R/Rcpp.package.skeleton.R index f0f2e697c..d8c989b50 100644 --- a/R/Rcpp.package.skeleton.R +++ b/R/Rcpp.package.skeleton.R @@ -1,4 +1,4 @@ -# Copyright (C) 2009 - 2016 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2009 - 2026 Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -24,17 +24,17 @@ 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) - call <- match.call() call[[1]] <- as.name("package.skeleton") env <- parent.frame(1) if (!is.character(cpp_files)) - stop("'cpp_files' must be a character vector") + stop("'cpp_files' must be a character vector") # #nocov if (!length(list)) { fake <- TRUE @@ -47,12 +47,12 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), } } else { if (example_code && !isTRUE(attributes)) { - if (!"rcpp_hello_world" %in% list) { + if (!"rcpp_hello_world" %in% list) { # #nocov start assign( "rcpp_hello_world", function() {}, envir = env) call[["list"]] <- as.call(c(as.name("c"), as.list(c("rcpp_hello_world", list)))) } - remove_hello_world <- TRUE + remove_hello_world <- TRUE # #nocov end } else { remove_hello_world <- FALSE } @@ -70,7 +70,7 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), } tryCatch(eval(call, envir = env), error = function(e){ - stop(sprintf("error while calling `package.skeleton` : %s", conditionMessage(e))) + stop(sprintf("error while calling `package.skeleton` : %s", conditionMessage(e))) # #nocov }) message("\nAdding Rcpp settings") @@ -81,32 +81,44 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), # Add Rcpp to the DESCRIPTION DESCRIPTION <- file.path(root, "DESCRIPTION") if (file.exists(DESCRIPTION)) { - imports <- c(if (isTRUE(module)) "methods", - sprintf("Rcpp (>= %s)", packageDescription("Rcpp")[["Version"]])) - x <- cbind(read.dcf(DESCRIPTION), + imports <- c(if (isTRUE(module)) "methods", sprintf("Rcpp (>= %s)", getRcppVersion())) + 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 NAMESPACE <- file.path(root, "NAMESPACE") lines <- readLines(NAMESPACE) ns <- file(NAMESPACE, open="w") - if (! 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) - } + if (!any(grepl("useDynLib", lines))) { + lines <- c(sprintf( "useDynLib(%s, .registration=TRUE)", name), lines) writeLines(lines, con = ns) message(" >> added useDynLib directive to NAMESPACE" ) } @@ -117,13 +129,16 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), writeLines('importFrom(Rcpp, evalCpp)', ns) message(" >> added importFrom(Rcpp, evalCpp) directive to NAMESPACE" ) } + if (!any(grepl("^exportPattern", lines))) { + writeLines("exportPattern(\"^[[:alpha:]]+\")", ns) + } close( ns ) ## 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) + .playWithPerPackageHelpPage(name, path, maintainer, email) # #nocov } ## lay things out in the src directory @@ -134,9 +149,9 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), skeleton <- system.file("skeleton", package = "Rcpp") if (length(cpp_files) > 0L) { - for (file in cpp_files) { + for (file in cpp_files) { # #nocov start file.copy(file, src) - message(" >> copied ", file, " to src directory" ) + message(" >> copied ", file, " to src directory" ) # #nocov end } } @@ -183,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.") - } + 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))) @@ -207,6 +218,11 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), rm("Rcpp.fake.fun", envir = env) unlink(file.path(root, "R" , "Rcpp.fake.fun.R")) unlink(file.path(root, "man", "Rcpp.fake.fun.Rd")) + + ## cleansing NAMESPACE of fake function entry + lines <- readLines(NAMESPACE) + lines <- lines[!grepl("^export.*fake\\.fun", lines)] + writeLines(lines, NAMESPACE) } if (isTRUE(remove_hello_world)) { @@ -226,7 +242,7 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), path = ".", maintainer = "Your Name", email = "your@mail.com") { - root <- file.path(path, name) + root <- file.path(path, name) # #nocov start helptgt <- file.path(root, "man", sprintf( "%s-package.Rd", name)) helpsrc <- system.file("skeleton", "manual-page-stub.Rd", package="Rcpp") ## update the package description help page @@ -238,5 +254,5 @@ Rcpp.package.skeleton <- function(name = "anRpackage", list = character(), lines, fixed = TRUE) writeLines(lines, helptgt) } - invisible(NULL) + invisible(NULL) # #nocov end } diff --git a/R/RcppClass.R b/R/RcppClass.R index f76a71cfe..1bd60f8c3 100644 --- a/R/RcppClass.R +++ b/R/RcppClass.R @@ -1,4 +1,4 @@ -# Copyright (C) 2010 - 2012 John Chambers, Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2010 - 2021 John Chambers, Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -26,8 +26,8 @@ setRcppClass <- function(Class, CppClass, ...) { myCall <- match.call() myCall[[1]] <- quote(Rcpp::loadRcppClass) - if(!missing(module) && moduleIsLoaded(module, where)) # eval now - eval.parent(myCall) + if (!missing(module) && moduleIsLoaded(module, where)) # eval now + eval.parent(myCall) # #nocov else { f <- function(NS)NULL myCall$where = as.name("NS") @@ -46,20 +46,20 @@ loadRcppClass <- function(Class, CppClass = Class, ...) { if(isBotchedSession()) { - value <- setRefClass(Class, fields = fields, methods = methods, contains = contains, where = where, ...) # kludge -- see loadModule.R + value <- setRefClass(Class, fields = fields, methods = methods, contains = contains, where = where, ...) # kludge -- see loadModule.R #nocov start if(is.character(saveAs) && length(saveAs) == 1) assign(saveAs, value, envir = where) - return(value) + return(value) # #nocov end } mod <- loadModule(module, NULL, env = where, loadNow = TRUE) storage <- get("storage", envir = as.environment(mod)) if(exists(Class, envir = storage, inherits = FALSE)) { cppclassinfo <- get(Class, envir = storage) if(!is(cppclassinfo, "C++Class")) - stop(gettextf("Object \"%s\" in module \"%s\" is not a C++ class description", Class, module)) + stop(gettextf("Object \"%s\" in module \"%s\" is not a C++ class description", Class, module)) # #nocov } else - stop(gettextf("No object \"%s\" in module \"%s\"", Class, module)) + stop(gettextf("No object \"%s\" in module \"%s\"", Class, module)) # #nocov allmethods <- .makeCppMethods(methods, cppclassinfo, where) allfields <- .makeCppFields(fields, cppclassinfo, where) value <- setRefClass(Class, fields = allfields, @@ -124,7 +124,7 @@ loadRcppClass <- function(Class, CppClass = Class, cppArgs <- !nzchar(argNames) .CppObject <<- do.call(.CppGenerator$new, args[cppArgs]) for(i in seq_along(args)[!cppArgs]) - field(argNames[[i]], args[[i]]) + field(argNames[[i]], args[[i]]) # #nocov } ), fields = list( @@ -135,7 +135,7 @@ loadRcppClass <- function(Class, CppClass = Class, .RcppClass$methods(show = function () { - cat("Rcpp class object of class ", classLabel(class(.self)), + cat("Rcpp class object of class ", classLabel(class(.self)), # #nocov start "\n", sep = "") fields <- names(.refClassDef@fieldClasses) if(".CppObject" %in% fields) { @@ -150,8 +150,5 @@ loadRcppClass <- function(Class, CppClass = Class, } }, objectPointer = function() - .CppObject$.pointer + .CppObject$.pointer # #nocov end ) - - - diff --git a/R/RcppLdpath.R b/R/RcppLdpath.R index a7fb32c80..d8acb323e 100644 --- a/R/RcppLdpath.R +++ b/R/RcppLdpath.R @@ -1,4 +1,4 @@ -# Copyright (C) 2010 - 2018 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -20,11 +20,20 @@ Rcpp.system.file <- function(...){ tools::file_path_as_absolute( base::system.file( ..., package = "Rcpp" ) ) } +## quote path if non-standard characters are used +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) # #nocov +} + ## Use R's internal knowledge of path settings to find the lib/ directory ## plus optinally an arch-specific directory on system building multi-arch 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'.") "" } @@ -39,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'.") "" } @@ -47,24 +57,25 @@ canUseCXX0X <- function() { TRUE } # .Call( "canUseCXX0X", PACKAGE = "Rcpp" ) ## Provide compiler flags -- i.e. -I/path/to/Rcpp.h RcppCxxFlags <- function(cxx0x=FALSE) { - # path <- RcppLdPath() path <- Rcpp.system.file( "include" ) if (.Platform$OS.type=="windows") { - path <- asBuildPath(path) + path <- asBuildPath(path) # #nocov } - paste("-I", path, if (cxx0x && canUseCXX0X()) " -std=c++0x" else "", sep="") + paste0('-I', Rcpp.quoteNonStandard(path)) } ## 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)) + 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()) } @@ -73,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.")) + 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() { - cat( RcppCxx0xFlags() ) + 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/tools.R b/R/tools.R index c1363699b..28fd3ca4a 100644 --- a/R/tools.R +++ b/R/tools.R @@ -1,4 +1,4 @@ -# Copyright (C) 2010 - 2017 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2010 - 2019 Dirk Eddelbuettel and Romain Francois # # This file is part of Rcpp. # @@ -24,11 +24,11 @@ forceAssignInNamespace <- function(x, value, env) { is_ns <- isNamespace(env) unlocker <- get("unlockBinding", baseenv()) if (is_ns && exists(x, env) && bindingIsLocked(x, env)) { - unlocker(x, env) + unlocker(x, env) # #nocov } assign(x, value, env) if (is_ns) { - lockBinding(x, env) + lockBinding(x, env) # #nocov } } @@ -48,3 +48,28 @@ asBuildPath <- function(path) { return(path) } + + +##' Helper function to report the package version of the R installation. +##' +##' While \code{packageVersion(Rcpp)} exports the version registers in +##' \code{DESCRIPTION}, this version does get incremented more easily +##' during development and can therefore be higher than the released +##' version. The actual \code{#define} long used at the C++ level +##' corresponds more to an \sQuote{API Version} which is now provided +##' by this function, and use for example in the package skeleton +##' generator. +##' +##' @title Export the Rcpp (API) Package Version +##' @param devel An logical value indicating if the development or +##' release version number should be returned, default is release. +##' @return A \code{package_version} object with either the release +##' or development version. +##' @author Dirk Eddelbuettel +##' @seealso \code{\link{packageVersion}}, +##' \code{\link{Rcpp.package.skeleton}} +##' @examples getRcppVersion() +getRcppVersion <- function(devel = FALSE) { + rcpp <- .Call("getRcppVersionStrings", PACKAGE="Rcpp") + package_version(rcpp[if(devel) 2 else 1]) +} diff --git a/R/unit.tests.R b/R/unit.tests.R deleted file mode 100644 index 185862558..000000000 --- a/R/unit.tests.R +++ /dev/null @@ -1,141 +0,0 @@ -# Copyright (C) 2010 - 2016 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 . - -test <- function(output=if(file.exists("/tmp")) "/tmp" else getwd(), - gctorture=FALSE, - gctorture.exclude="runit.Module.client.package.R") { - - if (requireNamespace("RUnit")) { # nocov start - - if (gctorture) { - - message("Running tests with gctorture(TRUE)") - if (length(gctorture.exclude)) { - message("The following tests will be excluded:\n", - paste(">>", gctorture.exclude, collapse="\n") - ) - } - - unitTestsDir <- system.file("unitTests", package="Rcpp") - files <- list.files( - unitTestsDir, - recursive=TRUE - ) - files <- setdiff(files, gctorture.exclude) - dirs <- list.dirs(unitTestsDir, full.names=FALSE) - testDir <- file.path( tempdir(), "RcppTests" ) - for (dir in file.path(testDir, dirs)) dir.create(dir) - - copySuccess <- sapply(files, function(file) { - file.copy( - file.path(unitTestsDir, file), - file.path(testDir, file) - ) - }) - - if (!all(copySuccess)) { - stop("Could not copy test files to temporary directory") - } - - ## Modify all the test files that were copied - testFiles <- list.files(testDir, pattern="^runit", full.names=TRUE) - for (file in testFiles) gctortureRUnitTest(file) - - ## Ensure we can read and parse each file - for (file in testFiles) { - tryCatch( parse(text=readLines(file)), - error=function(e) { - "could not parse test file" - } - ) - } - - } else { - testDir <- system.file("unitTests", package = "Rcpp") - } - - testSuite <- RUnit::defineTestSuite(name="Rcpp Unit Tests", - dirs=testDir, - testFuncRegexp = "^[Tt]est.+") - - ## if someoone calls Rcpp::test(), he/she wants all tests - Sys.setenv("RunAllRcppTests"="yes") - - ## Run tests - tests <- RUnit::runTestSuite(testSuite) - - ## Print results - RUnit::printTextProtocol(tests) - - return(tests) - } - - stop("Running unit tests requires the 'RUnit' package.") # nocov end -} - -unitTestSetup <- function(file, packages=NULL, - pathToRcppTests=system.file("unitTests", package = "Rcpp"), - ...) { - function() { - if (! is.null(packages)) { - for (p in packages) { - suppressMessages(require(p, character.only=TRUE)) - } - } - sourceCpp(file.path(pathToRcppTests, "cpp", file), ...) - } -} - -gctortureRUnitTest <- function(file) { - - test <- readLines(file) # nocov start - - ## todo: handle '{', '}' within quotes - findMatchingBrace <- function(test, start, balance=1) { - line <- test[start] - if (start > length(test)) { - stop("error") - } - if (balance > 0) { - balance <- balance + - sum(gregexpr("{", line, fixed=TRUE)[[1]] > 0) - - sum(gregexpr("}", line, fixed=TRUE)[[1]] > 0) - return( findMatchingBrace(test, start+1, balance) ) - } - return(start - 1) - } - - ## Find the lines defining unit tests - testStarts <- grep("^[[:space:]]*[Tt]est\\.+", test) - - ## Get the line with the closing brace - testEnds <- sapply(testStarts, function(ind) { - findMatchingBrace(test, ind + 1) - }) - stopifnot( length(testStarts) == length(testEnds) ) - - ## Modify the function definition by wrapping it in gctorture - for (i in seq_along(testStarts)) { - start <- testStarts[i] - end <- testEnds[i] - test[start] <- paste( test[start], "gctorture(TRUE);" ) - test[end] <- paste("gctorture(FALSE); }") - } - - cat(test, file=file, sep="\n") # 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 0acd8cd08..bb42b2f21 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,25 @@ -## Rcpp [![Build Status](https://travis-ci.org/RcppCore/Rcpp.svg)](https://travis-ci.org/RcppCore/Rcpp) [![License](https://eddelbuettel.github.io/badges/GPL2+.svg)](http://www.gnu.org/licenses/gpl-2.0.html) [![CRAN](http://www.r-pkg.org/badges/version/Rcpp)](https://cran.r-project.org/package=Rcpp) [![Downloads](http://cranlogs.r-pkg.org/badges/Rcpp?color=brightgreen)](http://www.r-pkg.org/pkg/Rcpp) [![Coverage Status](https://codecov.io/gh/RcppCore/Rcpp/graph/badge.svg)](https://codecov.io/github/RcppCore/Rcpp?branch=master) - -### Seamless R and C++ Integration - -The [Rcpp package](https://cran.r-project.org/package=Rcpp) provides R -functions and a (header-only for client packages) C++ library greatly -facilitating the integration of R and C++. +## Rcpp: Seamless R and C++ Integration + +[![CI](https://github.com/RcppCore/Rcpp/workflows/ci/badge.svg)](https://github.com/RcppCore/Rcpp/actions?query=workflow%3Aci) +[![License](https://eddelbuettel.github.io/badges/GPL2+.svg)](https://www.gnu.org/licenses/gpl-2.0.html) +[![CRAN](https://www.r-pkg.org/badges/version/Rcpp)](https://cran.r-project.org/package=Rcpp) +[![Dependencies](https://tinyverse.netlify.app/badge/Rcpp)](https://cran.r-project.org/package=Rcpp) +[![Coverage Status](https://codecov.io/gh/RcppCore/Rcpp/graph/badge.svg)](https://app.codecov.io/github/RcppCore/Rcpp?branch=master) +[![Debian package](https://img.shields.io/debian/v/r-cran-rcpp/sid?color=brightgreen)](https://packages.debian.org/sid/r-cran-rcpp) +[![r-universe](https://rcppcore.r-universe.dev/badges/Rcpp)](https://rcppcore.r-universe.dev/Rcpp) +[![Last Commit](https://img.shields.io/github/last-commit/RcppCore/Rcpp)](https://github.com/RcppCore/Rcpp) +[![Downloads (monthly)](https://cranlogs.r-pkg.org/badges/Rcpp?color=brightgreen)](https://www.r-pkg.org/pkg/Rcpp) +[![Downloads (total)](https://cranlogs.r-pkg.org/badges/grand-total/Rcpp?color=brightgreen)](https://www.r-pkg.org/pkg/Rcpp) +[![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://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 + +The [Rcpp package](https://cran.r-project.org/package=Rcpp) integrates R and C++ via R functions and a (header-only) C++ library. All underlying R types and objects, _i.e._, everything a `SEXP` represents internally in R, are matched to corresponding C++ objects. This covers anything from vectors, @@ -15,14 +30,14 @@ represented as instances of `Rcpp::Environment`, functions are represented as `Rcpp::Function`, etc ... The [Rcpp-introduction](https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-introduction.pdf) vignette (now published as a -[TAS paper](https://amstat.tandfonline.com/doi/abs/10.1080/00031305.2017.1375990); an +[TAS paper](https://doi.org/10.1080/00031305.2017.1375990); an [earlier introduction](https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-jss-2011.pdf) -was also published as a [JSS paper](http://www.jstatsoft.org/v40/i08/)) +was also published as a [JSS paper](https://doi.org/10.18637/jss.v040.i08) provides a good entry point to Rcpp as do the [Rcpp -website](http://www.rcpp.org), the [Rcpp -page](http://dirk.eddelbuettel.com/code/rcpp.html) and the [Rcpp -Gallery](http://gallery.rcpp.org). Full documentation is provided by the -[Rcpp book](http://www.rcpp.org/book/). +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://link.springer.com/book/10.1007/978-1-4614-6868-4). Other highlights: @@ -50,31 +65,43 @@ See the [Rcpp-atttributes](https://cran.r-project.org/package=Rcpp/vignettes/Rcp ### Documentation -The package ships with nine pdf vignettes, including a [recent introduction to +The package ships with ten pdf vignettes, including a [recent introduction to Rcpp](https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-introduction.pdf) now published as a [paper in -TAS](https://amstat.tandfonline.com/doi/abs/10.1080/00031305.2017.1375990) (and as a +TAS](https://doi.org/10.1080/00031305.2017.1375990) (and as a [preprint in PeerJ](https://peerj.com/preprints/3188/)). Also available is an [earlier introduction](https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-jss-2011.pdf) -which was published as a [JSS paper](http://www.jstatsoft.org/v40/i08/)) +which was published as a [JSS paper](https://doi.org/10.18637/jss.v040.i08). 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](http://www.rcpp.org/book) +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 + +Rcpp follows the C++ motto of _"you pay only for what you use"_ and imposes +no _run-time_ performance penalty: Rcpp outperforms related packages in +direct comparison, see for example [this repo for +details](https://github.com/eddelbuettel/ldlasb). + +Compile-time performance can be tuned by selecting components. But it is also +worth noting that use of [`ccache`](https://ccache.dev/) will (strongly) +dominate all such possible component choices, we have [previously +recommended](https://dirk.eddelbuettel.com/blog/2017/11/27/) its use. + ### Examples -The [Rcpp Gallery](http://gallery.rcpp.org) showcases over one hundred fully +The [Rcpp Gallery](https://gallery.rcpp.org) showcases over one hundred fully documented and working examples. The [package RcppExamples](https://cran.r-project.org/package=RcppExamples) contains a few basic examples covering the core data types. -A number of examples are included as are 1429 unit tests in 618 unit -test functions provide additional usage examples. +A number of examples are included, as are well over one thousand unit tests which provide +additional usage examples. An earlier version of Rcpp, containing what we now call the 'classic Rcpp API' was written during 2005 and 2006 by Dominick Samperi. This code has @@ -82,40 +109,66 @@ 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 July 2018, -there are 1408 [CRAN](https://cran.r-project.org) packages using Rcpp, a further -91 [BioConductor](http://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. +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 100.6 million times (per the partial logs from the cloud mirrors +of CRAN). ### Installation -Released and tested versions of Rcpp are available via the -[CRAN](https://cran.r-project.org) network, and can be installed from within R via +#### CRAN + +Rcpp released on CRAN are carefully tested and curated. CRAN ensures they interoperate +with all other CRAN package on all test environment. The released and tested versions +are available via all mirrors of [CRAN](https://cran.r-project.org) network, and can be +installed from within R via ```R install.packages("Rcpp") ``` +#### Release Candidates + +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 = c("https://rcppcore.r-universe.dev", + "https://cloud.r-project.org")) +``` + +where other repos can be set as needed. + +Testing the release candidates prior to the actual release helps. Please run +this if you can. + +#### Source + To install from source, ensure you have a complete package development environment for R as discussed in the relevant documentation; also see questions 1.2 and 1.3 in the [Rcpp-FAQ](https://cran.r-project.org/package=Rcpp/vignettes/Rcpp-FAQ.pdf). -### Support +#### Less Common Versions and Platforms -The best place for questions is the -[Rcpp-devel](http://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. +If you want to run Rcpp on another (not-tested on CRAN) platform, or on releases +older than the previous release, we suggest you do your due diligence and test +accordingly. Rcpp is provided by an all-volunteer team with finite resources. +We work hard to test Rcpp with several thousand CRAN packages using it---but +we cannot test on outdated versions of R or your OS. + +### Support -Another option is to use -[StackOverflow and its 'rcpp' tag](http://stackoverflow.com/questions/tagged/rcpp). -Search functionality (use `rcpp` in squared brackets as in -[[rcpp] my question terms](https://stackoverflow.com/search?q=[rcpp]%20my%20question%20terms) -to tag the query) is very valuable as many questions have indeed been asked, and -answered, 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, @@ -125,7 +178,7 @@ previous issues can be searched as well. ### Authors Dirk Eddelbuettel, Romain Francois, JJ Allaire, Kevin Ushey, Qiang Kou, -Nathan Russell, Doug Bates, and John Chambers +Nathan Russell, Iñaki Ucar, Doug Bates, and John Chambers ### License diff --git a/cleanup b/cleanup index 6a45b9c0b..e334f7c5c 100755 --- a/cleanup +++ b/cleanup @@ -1,4 +1,4 @@ -#!/bin/bash +#!/bin/sh #cd inst/doc && rm -f index.html *.tex *.bbl *.blg *.aux *.out *.log && cd - @@ -30,7 +30,12 @@ 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 {} \; + +(test -d vignettes/ && cd vignettes/ && test -f Makefile && make clean && cd -) >/dev/null +(test -d vignettes/rmd && cd vignettes/rmd/ && test -f Makefile && make clean && cd -) >/dev/null diff --git a/debian/changelog b/debian/changelog deleted file mode 100644 index ddce6a315..000000000 --- a/debian/changelog +++ /dev/null @@ -1,567 +0,0 @@ -rcpp (0.12.18-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - * debian/control: Set Build-Depends: to 'debhelper (>= 10)' - * debian/control: Set Standards-Version: to current version - - -- Dirk Eddelbuettel Mon, 23 Jul 2018 08:45:35 -0500 - -rcpp (0.12.17-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - * debian/control: Set Standards-Version: to current version - * debian/control: Add Vcs-Browser: and Vcs-Git: - * debian/control: Switch from cdbs to dh-r - * debian/rules: Idem - - * debian/control: Add Depends: on r-cran-littler (Closes: #897973) - - -- Dirk Eddelbuettel Tue, 22 May 2018 21:49:21 -0500 - -rcpp (0.12.16-1) unstable; urgency=medium - - * New upstream release - - -- Dirk Eddelbuettel Thu, 08 Mar 2018 06:31:16 -0600 - -rcpp (0.12.15-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Standards-Version: to current version - - -- Dirk Eddelbuettel Tue, 16 Jan 2018 06:04:40 -0600 - -rcpp (0.12.14-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - * debian/control: Set Standards-Version: to current version - - -- Dirk Eddelbuettel Sun, 03 Dec 2017 18:50:23 -0600 - -rcpp (0.12.13-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - * debian/control: Set Standards-Version: to current version - * debian/compat: Increase level to 9 - - -- Dirk Eddelbuettel Sat, 30 Sep 2017 07:59:04 -0500 - -rcpp (0.12.12-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Thu, 13 Jul 2017 06:01:18 -0500 - -rcpp (0.12.11-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Tue, 23 May 2017 15:14:02 -0500 - -rcpp (0.12.10-1) unstable; urgency=medium - - * New upstream release - - -- Dirk Eddelbuettel Fri, 17 Mar 2017 06:28:08 -0500 - -rcpp (0.12.9-1) unstable; urgency=medium - - * New upstream release - - -- Dirk Eddelbuettel Sat, 14 Jan 2017 09:18:21 -0500 - -rcpp (0.12.8-1) unstable; urgency=medium - - * New upstream release - - -- Dirk Eddelbuettel Fri, 18 Nov 2016 06:19:40 -0600 - -rcpp (0.12.7-1) unstable; urgency=medium - - * New upstream release - - -- Dirk Eddelbuettel Sun, 04 Sep 2016 08:07:47 -0500 - -rcpp (0.12.6-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - * debian/control: Set Standards-Version: to current version - - -- Dirk Eddelbuettel Mon, 18 Jul 2016 20:16:27 -0500 - -rcpp (0.12.5-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Sat, 14 May 2016 10:56:27 -0500 - -rcpp (0.12.4-1) unstable; urgency=medium - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Tue, 22 Mar 2016 06:24:28 -0500 - -rcpp (0.12.3-1) unstable; urgency=low - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Sun, 10 Jan 2016 08:43:36 -0600 - -rcpp (0.12.2-1) unstable; urgency=low - - * New upstream release - - -- Dirk Eddelbuettel Sat, 14 Nov 2015 08:49:02 -0600 - -rcpp (0.12.1-1) unstable; urgency=low - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Thu, 10 Sep 2015 05:14:40 -0500 - -rcpp (0.12.0-1) unstable; urgency=low - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Fri, 24 Jul 2015 08:42:26 -0500 - -rcpp (0.11.6-1) unstable; urgency=low - - * New upstream release - - -- Dirk Eddelbuettel Fri, 01 May 2015 06:20:46 -0500 - -rcpp (0.11.5-1) unstable; urgency=low - - * New upstream release - - -- Dirk Eddelbuettel Wed, 04 Mar 2015 14:30:22 -0600 - -rcpp (0.11.4-1) unstable; urgency=low - - * New upstream release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Sat, 24 Jan 2015 14:52:51 -0600 - -rcpp (0.11.3-1) unstable; urgency=low - - * New upstream release - - * debian/control: New (Build-)Depends: on r-cran-pkgkitten - - * debian/control: Set Build-Depends: to current R version - * debian/control: Set Standards-Version: to current version - - -- Dirk Eddelbuettel Mon, 29 Sep 2014 19:54:50 -0500 - -rcpp (0.11.2-1) unstable; urgency=low - - * New release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Fri, 06 Jun 2014 18:09:54 -0500 - -rcpp (0.11.1-1) unstable; urgency=low - - * New release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Thu, 13 Mar 2014 20:20:11 -0500 - -rcpp (0.11.0-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sun, 02 Feb 2014 08:22:46 -0600 - -rcpp (0.10.6-1) unstable; urgency=low - - * New release - * debian/control: Set Build-Depends: to current R version - * debian/control: Set Standards-Version: to current version - * debian/control: Add 'r-cran-codetools' to Build-Depends (as it is - used at preparation for LazyLoading stage) - - -- Dirk Eddelbuettel Tue, 29 Oct 2013 09:42:30 -0500 - -rcpp (0.10.5-1) unstable; urgency=low - - * New release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Sat, 28 Sep 2013 07:28:48 -0500 - -rcpp (0.10.4-1) unstable; urgency=low - - * New release - - * debian/control: Set Build-Depends: to current R version - - -- Dirk Eddelbuettel Sun, 23 Jun 2013 09:02:24 -0500 - -rcpp (0.10.3-2) unstable; urgency=low - - * debian/control: Set Build-Depends: to current R version - - * (Re-)building with R 3.0.0 (beta) - - -- Dirk Eddelbuettel Sat, 30 Mar 2013 18:04:44 -0500 - -rcpp (0.10.3-1) unstable; urgency=low - - * New release - - * src/Timer.cpp: Changed to permit *BSD builds (Closes: #697032) - - -- Dirk Eddelbuettel Sat, 23 Mar 2013 07:42:26 -0500 - -rcpp (0.10.2-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 21 Dec 2012 06:22:53 -0600 - -rcpp (0.10.1-1) unstable; urgency=low - - * New release - - * inst/include/Rcpp/iostream/Rostream.h: Additional fix that didn't make - it into 0.10.1 - - -- Dirk Eddelbuettel Tue, 27 Nov 2012 08:20:54 -0600 - -rcpp (0.10.0-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 13 Nov 2012 19:55:10 -0600 - -rcpp (0.9.15-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sat, 13 Oct 2012 16:01:04 -0500 - -rcpp (0.9.14-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sun, 30 Sep 2012 08:07:51 -0500 - -rcpp (0.9.13-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Thu, 28 Jun 2012 21:20:47 -0500 - -rcpp (0.9.12-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sat, 23 Jun 2012 11:20:06 -0500 - -rcpp (0.9.11-1) unstable; urgency=low - - * New release - - * debian/control: Set Build-Depends: to current R version - * debian/control: Change Depends to ${R:Depends} - * debian/control: Set Standards-Version: to current version - - -- Dirk Eddelbuettel Fri, 22 Jun 2012 06:22:00 -0500 - -rcpp (0.9.10-1) unstable; urgency=low - - * New release - - * debian/control: Updated (Build-)Depends: to current R version - - -- Dirk Eddelbuettel Wed, 15 Feb 2012 07:10:16 -0600 - -rcpp (0.9.9-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sun, 25 Dec 2011 09:30:03 -0600 - -rcpp (0.9.8-1) unstable; urgency=low - - * New release - - * debian/control: Updated Standard-Versions: to current version - * debian/control: Updated (Build-)Depends: to current R version - - -- Dirk Eddelbuettel Wed, 21 Dec 2011 10:50:09 -0600 - -rcpp (0.9.7-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Thu, 29 Sep 2011 14:53:21 -0500 - -rcpp (0.9.6-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 26 Jul 2011 19:18:20 -0500 - -rcpp (0.9.5-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 05 Jul 2011 21:14:26 -0500 - -rcpp (0.9.4-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 12 Apr 2011 10:12:37 -0500 - -rcpp (0.9.3-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 05 Apr 2011 12:11:12 -0500 - -rcpp (0.9.2-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Wed, 23 Feb 2011 13:58:14 -0600 - -rcpp (0.9.1-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Mon, 14 Feb 2011 06:54:24 -0600 - -rcpp (0.9.0-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sun, 19 Dec 2010 18:35:01 -0600 - -rcpp (0.8.9-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sat, 27 Nov 2010 22:53:27 -0600 - -rcpp (0.8.8-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Mon, 01 Nov 2010 17:16:36 -0500 - -rcpp (0.8.7-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 15 Oct 2010 05:12:31 -0500 - -rcpp (0.8.6-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Thu, 09 Sep 2010 12:21:21 -0500 - -rcpp (0.8.5-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sun, 25 Jul 2010 11:34:27 -0500 - -rcpp (0.8.4-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 09 Jul 2010 09:39:20 -0500 - -rcpp (0.8.3-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sun, 27 Jun 2010 16:40:23 -0500 - -rcpp (0.8.2-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Wed, 09 Jun 2010 11:03:23 -0500 - -rcpp (0.8.1-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 08 Jun 2010 05:18:34 -0500 - -rcpp (0.8.0-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Mon, 17 May 2010 06:41:54 -0500 - -rcpp (0.7.12-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 16 Apr 2010 06:23:46 -0500 - -rcpp (0.7.11-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 26 Mar 2010 15:14:58 -0500 - -rcpp (0.7.10-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Mon, 15 Mar 2010 14:58:40 -0500 - -rcpp (0.7.9-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 12 Mar 2010 12:25:52 -0600 - -rcpp (0.7.8-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 09 Mar 2010 11:39:12 -0600 - -rcpp (0.7.7-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sun, 14 Feb 2010 11:53:46 -0600 - -rcpp (0.7.6-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 12 Feb 2010 21:50:34 -0600 - -rcpp (0.7.5-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Mon, 08 Feb 2010 09:36:13 -0600 - -rcpp (0.7.4-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sat, 30 Jan 2010 14:36:24 -0600 - -rcpp (0.7.3-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Thu, 21 Jan 2010 20:42:07 -0600 - -rcpp (0.7.2-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 12 Jan 2010 20:41:16 -0600 - -rcpp (0.7.1-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Sat, 02 Jan 2010 15:38:09 -0600 - -rcpp (0.7.0-1) unstable; urgency=low - - * New release - - * debian/control: Added littler to Depends: as examples use it [lintian] - - -- Dirk Eddelbuettel Sat, 19 Dec 2009 14:18:32 -0600 - -rcpp (0.6.8-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Tue, 10 Nov 2009 07:34:07 -0600 - -rcpp (0.6.7-1) unstable; urgency=low - - * New release - - * debian/control: Updated Standard-Versions: to current version - * debian/control: Updated (Build-)Depends: to current R version - - -- Dirk Eddelbuettel Sun, 08 Nov 2009 19:22:53 -0600 - -rcpp (0.6.6-1) unstable; urgency=low - - * New release - - * debian/control: Updated Standard-Versions: to current version - * debian/control: Updated (Build-)Depends: to current R version - - -- Dirk Eddelbuettel Mon, 03 Aug 2009 14:55:48 -0500 - -rcpp (0.6.5-1) unstable; urgency=low - - * New release - - * COPYING: Added license file (Closes: #522202) - - -- Dirk Eddelbuettel Wed, 01 Apr 2009 21:34:33 -0500 - -rcpp (0.6.4-1) unstable; urgency=low - - * New release - - * debian/r-cran-rcpp.lintian-overrides: Added to suppress lintian - warnings over Doxygen-generated png files - - -- Dirk Eddelbuettel Sun, 01 Mar 2009 17:41:58 -0600 - -rcpp (0.6.3-1) unstable; urgency=low - - * New release - - -- Dirk Eddelbuettel Fri, 09 Jan 2009 20:41:35 -0600 - -rcpp (0.6.2-1) unstable; urgency=low - - * Initial Debian release (Closes: #507941) - - -- Dirk Eddelbuettel Fri, 05 Dec 2008 19:58:31 -0600 - - diff --git a/debian/compat b/debian/compat deleted file mode 100644 index ec635144f..000000000 --- a/debian/compat +++ /dev/null @@ -1 +0,0 @@ -9 diff --git a/debian/control b/debian/control deleted file mode 100644 index 9c4b216aa..000000000 --- a/debian/control +++ /dev/null @@ -1,24 +0,0 @@ -Source: rcpp -Section: gnu-r -Priority: optional -Maintainer: Dirk Eddelbuettel -Build-Depends: debhelper (>= 10), r-base-dev (>= 3.5.1), dh-r, r-cran-codetools, r-cran-pkgkitten -Standards-Version: 4.1.5 -Vcs-Browser: https://salsa.debian.org/edd/r-cran-rcpp -Vcs-Git: https://salsa.debian.org/edd/r-cran-rcpp.git -Homepage: http://dirk.eddelbuettel.com/code/rcpp.html - -Package: r-cran-rcpp -Architecture: any -Depends: ${shlibs:Depends}, ${misc:Depends}, ${R:Depends}, littler, r-cran-littler, r-cran-pkgkitten -Suggests: r-cran-inline -Description: GNU R package for Seamless R and C++ Integration - 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 - code as well as easier integration of third-party libraries. Documentation - about Rcpp is provided by several vignettes included in this package, via the - Rcpp Gallery site at http://gallery.rcpp.org, the paper by Eddelbuettel and - Francois (2011, JSS), and the book by Eddelbuettel (2013, Springer); see - 'citation("Rcpp")' for details on these last two. - diff --git a/debian/copyright b/debian/copyright deleted file mode 100644 index ce62ff85f..000000000 --- a/debian/copyright +++ /dev/null @@ -1,57 +0,0 @@ -This is the Debian GNU/Linux r-cran-rcpp package of Rcpp, an -R / C++ interface package. Rcpp was written by Dominick Samperi, -Dirk Eddelbuettel and Romain Francois. - -This package was created by Dirk Eddelbuettel . -The sources were downloaded from the main CRAN site - http://cran.r-project.org/src/contrib/ -and are also available from all CRAN mirrors as e.g. - http://cran.us.r-project.org/src/contrib/ -as well the GitHub repo - http://github.com/RcppCore/Rcpp - -The package was renamed from its upstream name 'Rcpp' to -'r-cran-rcpp' to fit the pattern of CRAN (and non-CRAN) packages for -R. - -Copyright (C) 2005 - 2006 Dominick Samperi -Copyright (C) 2008 Dirk Eddelbuettel -Copyright (C) 2009 - 2013 Dirk Eddelbuettel and Romain Francois - -Portions Copyright (C) 2008 Simon Urbanek -Portions Copyright (C) 2010 Doug Bates -Portions Copyright (C) 2010 John M Chambers - -License: GPL-2 - -On a Debian GNU/Linux system, the GPL license (version 2) is included -in the file /usr/share/common-licenses/GPL-2. - -For reference, the upstream DESCRIPTION file is included below: - - Package: Rcpp - Title: Rcpp R/C++ interface package - Version: 0.7.3 - Date: $Date: 2010-01-18 13:08:15 -0600 (Mon, 18 Jan 2010) $ - Author: Dirk Eddelbuettel and Romain Francois, with contributions - by Simon Urbanek and David Reiss; based on code written during - 2005 and 2006 by Dominick Samperi - Maintainer: Dirk Eddelbuettel - Description: R/C++ interface classes and examples - The Rcpp library maps data types betweeen R and C++, and includes support - for R types real, integer, character, vector, matrix, Date, datetime (i.e. - POSIXct) at microsecond resolution, data frame, and function. Transfer to and - from simple SEXP objects is particular easy. Calling R functions from C++ is - also supported. - . - C++ code can be 'inlined' by using the 'inline' package which will create a - C++ function and compile, link and load it given the 'inlined' character - argument which makes C++ integration very easy. - . - Several examples are included. - Depends: R (>= 2.0.0) - Suggests: inline (>= 0.3.4), RUnit - SystemRequirements: None - URL: http://dirk.eddelbuettel.com/code/rcpp.html, - http://romainfrancois.blog.free.fr/index.php?category/R-package/Rcpp - License: GPL (>= 2) diff --git a/debian/r-cran-rcpp.lintian-overrides b/debian/r-cran-rcpp.lintian-overrides deleted file mode 100644 index 40ce76e64..000000000 --- a/debian/r-cran-rcpp.lintian-overrides +++ /dev/null @@ -1,96 +0,0 @@ -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RObject.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.XPTr.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.environments.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.evaluator.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.exceptions.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RObject.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.XPTr.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.environments.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.evaluator.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.exceptions.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/ConvolveBenchmarks/convolve2.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/ConvolveBenchmarks/exampleRCode.r -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.CharacterVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.ComplexVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.ExpressionVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Function.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.GenericVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.IntegerVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Language.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.NumericVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Pairlist.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RawVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.S4.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Symbol.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.as.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.wrap.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/discovery/cxx0x.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppDate.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppDatetime.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppMatrix.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppMatrixView.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppParams.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppResultSet.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppVector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppVectorView.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.clone.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.traits.R -r-cran-rcpp: script-uses-bin-env usr/lib/R/site-library/Rcpp/discovery/cxx0x.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Column.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Matrix.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Row.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.macros.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Argument.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppFrame.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Vector.create.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.DataFrame.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Dimension.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Formula.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.client.package.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Module.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.complex.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Date.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Datetime.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.sugar.R -r-cran-rcpp: executable-not-elf-or-script ./usr/lib/R/site-library/Rcpp/examples/SugarPerformance/sugarBenchmarks.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.RcppMisc.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Vector.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.misc.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.stats.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/ConvolveBenchmarks/buildAndRun.sh -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/ConvolveBenchmarks/overhead.r -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/functionCallback/buildAndRun.sh -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Module.client.package.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.modref.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.support.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/Misc/ifelseLooped.r -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/OpenMP/OpenMPandInline.r -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.int64.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.rcout.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.sugarOps.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/Misc/newFib.r -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.rmath.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.String.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.wstring.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Reference.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/examples/ConvolveBenchmarks/overhead.sh -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.na.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.subset.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.table.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.attributes.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.InternalFunction.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.InternalFunctionCPP11.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.binary.package.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.sugar.var.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.algorithm.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.dispatch.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.quickanddirty.R -r-cran-rcpp: missing-dep-for-interpreter r => littler (usr/lib/R/site-library/Rcpp/examples/ConvolveBenchmarks/exampleRCode.r) -r-cran-rcpp: missing-dep-for-interpreter r => littler (usr/lib/R/site-library/Rcpp/examples/FastLM/benchmark.r) -r-cran-rcpp: missing-dep-for-interpreter r => littler (usr/lib/R/site-library/Rcpp/examples/FastLM/benchmarkLongley.r) -r-cran-rcpp: missing-dep-for-interpreter ... use --no-tag-display-limit to see all (or pipe to a file/program) -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.system.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.Exceptions_nocall.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.embeddedR.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.interface.R -r-cran-rcpp: script-not-executable usr/lib/R/site-library/Rcpp/unitTests/runit.stack.R diff --git a/debian/rules b/debian/rules deleted file mode 100755 index 2a7d92f03..000000000 --- a/debian/rules +++ /dev/null @@ -1,7 +0,0 @@ -#!/usr/bin/make -f -# -*- makefile -*- -# debian/rules file for the Debian/GNU Linux rcpp package -# Copyright 2003 - 2018 by Dirk Eddelbuettel - -%: - dh $@ --buildsystem R diff --git a/debian/source/format b/debian/source/format deleted file mode 100644 index 163aaf8d8..000000000 --- a/debian/source/format +++ /dev/null @@ -1 +0,0 @@ -3.0 (quilt) diff --git a/debian/watch b/debian/watch deleted file mode 100644 index 79f94fe40..000000000 --- a/debian/watch +++ /dev/null @@ -1,2 +0,0 @@ -version=3 -http://cran.r-project.org/src/contrib/Rcpp_([-\d\.]*)\.tar.gz diff --git a/docker/ci-3.4/Dockerfile b/docker/ci-3.4/Dockerfile new file mode 100644 index 000000000..fc4508a2e --- /dev/null +++ b/docker/ci-3.4/Dockerfile @@ -0,0 +1,18 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:3.4.4 + +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/docker/ci-3.5/Dockerfile b/docker/ci-3.5/Dockerfile new file mode 100644 index 000000000..601ad219e --- /dev/null +++ b/docker/ci-3.5/Dockerfile @@ -0,0 +1,17 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:3.5.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/docker/ci-3.6/Dockerfile b/docker/ci-3.6/Dockerfile new file mode 100644 index 000000000..ba31bd715 --- /dev/null +++ b/docker/ci-3.6/Dockerfile @@ -0,0 +1,17 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:3.6.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/docker/ci-4.0/Dockerfile b/docker/ci-4.0/Dockerfile new file mode 100644 index 000000000..a4247878f --- /dev/null +++ b/docker/ci-4.0/Dockerfile @@ -0,0 +1,17 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:4.0.5 + +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/docker/ci-4.1/Dockerfile b/docker/ci-4.1/Dockerfile new file mode 100644 index 000000000..9c73b601d --- /dev/null +++ b/docker/ci-4.1/Dockerfile @@ -0,0 +1,17 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:4.1.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/docker/ci-4.2/Dockerfile b/docker/ci-4.2/Dockerfile new file mode 100644 index 000000000..01cecbc16 --- /dev/null +++ b/docker/ci-4.2/Dockerfile @@ -0,0 +1,17 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:4.2.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/docker/ci-4.3/Dockerfile b/docker/ci-4.3/Dockerfile new file mode 100644 index 000000000..34e2ed8d9 --- /dev/null +++ b/docker/ci-4.3/Dockerfile @@ -0,0 +1,17 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM r-base:4.3.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/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/docker/ci-dev/Dockerfile b/docker/ci-dev/Dockerfile new file mode 100644 index 000000000..66d8cb71f --- /dev/null +++ b/docker/ci-dev/Dockerfile @@ -0,0 +1,18 @@ +## Emacs, make this -*- mode: sh; -*- + +FROM rocker/drd + +LABEL org.label-schema.license="GPL-2.0" \ + org.label-schema.vcs-url="https://github.com/RcppCore/Rcpp" \ + maintainer="Dirk Eddelbuettel " + +RUN rm -f /etc/apt/sources.list.d/experimental.list \ + && apt update -y \ + && apt install -y --no-install-recommends git \ + && RDscript -e 'install.packages(c("codetools", "inline", "pkgKitten", "rbenchmark", "tinytest"))' + +ENV _R_CHECK_FORCE_SUGGESTS_ FALSE +ENV _R_CHECK_TESTS_NLINES_ 0 +ENV RunAllRcppTests yes + +CMD ["bash"] diff --git a/docker/ci/Dockerfile b/docker/ci/Dockerfile index cab611907..494c47d67 100644 --- a/docker/ci/Dockerfile +++ b/docker/ci/Dockerfile @@ -1,6 +1,6 @@ ## Emacs, make this -*- mode: sh; -*- -FROM r-base:latest +FROM rocker/r2u:latest LABEL org.label-schema.license="GPL-2.0" \ org.label-schema.vcs-url="https://github.com/RcppCore/Rcpp" \ @@ -8,20 +8,18 @@ LABEL org.label-schema.license="GPL-2.0" \ RUN apt-get update \ && apt-get install -y --no-install-recommends \ - r-cran-runit \ + libcurl4-openssl-dev \ + libssl-dev \ + r-cran-covr \ r-cran-inline \ - r-cran-rmarkdown \ - r-cran-knitr \ r-cran-pkgkitten \ - r-cran-curl \ - r-cran-openssl \ - r-cran-httr \ - r-cran-lazyeval \ - r-cran-withr \ + r-cran-tinytest \ + r-cran-xml2 \ git \ - && install.r rbenchmark pinp covr \ - && mkdir ~/.R \ - && echo _R_CHECK_FORCE_SUGGESTS_=FALSE > ~/.R/check.Renviron \ - && echo RunAllRcppTests=yes >> ~/.R/check.Renviron + && install.r rbenchmark + +ENV _R_CHECK_FORCE_SUGGESTS_ FALSE +ENV _R_CHECK_TESTS_NLINES_ 0 +ENV RunAllRcppTests yes CMD ["bash"] diff --git a/docker/plus/Dockerfile b/docker/plus/Dockerfile index 86d56bb2e..22504eaa8 100644 --- a/docker/plus/Dockerfile +++ b/docker/plus/Dockerfile @@ -8,9 +8,20 @@ LABEL org.label-schema.license="GPL-2.0" \ RUN apt-get update \ && apt-get install -y --no-install-recommends \ + r-cran-bh \ + r-cran-bit64 \ + r-cran-curl \ + r-cran-httr \ + r-cran-knitr \ + r-cran-lazyeval \ + r-cran-microbenchmark \ + r-cran-openssl \ + r-cran-pinp \ r-cran-rcpparmadillo \ r-cran-rcppeigen \ r-cran-rcppgsl \ - && install.r microbenchmark BH + r-cran-rmarkdown \ + r-cran-runit \ + r-cran-withr CMD ["bash"] diff --git a/inst/CITATION b/inst/CITATION index 3e5330e9e..3e761e663 100644 --- a/inst/CITATION +++ b/inst/CITATION @@ -1,52 +1,41 @@ -citHeader("To cite Rcpp in publications use:") +bibentry("Manual", + other = unlist(citation(auto = meta), recursive = FALSE)) -citEntry(entry = "Article", +bibentry("Article", title = "{Rcpp}: Seamless {R} and {C++} Integration", - author = personList(as.person("Dirk Eddelbuettel"), - as.person("Romain Fran\\c{c}ois")), + author = c(person("Dirk", "Eddelbuettel", + email = "edd@debian.org", + comment = c(ORCID = "0000-0001-6419-907X")), + person("Romain", "Fran\\c{c}ois")), journal = "Journal of Statistical Software", year = "2011", volume = "40", number = "8", pages = "1--18", - url = "http://www.jstatsoft.org/v40/i08/", - doi = "10.18637/jss.v040.i08", + doi = "10.18637/jss.v040.i08") - textVersion = paste("Dirk Eddelbuettel and Romain Francois (2011).", - "Rcpp: Seamless R and C++ Integration.", - "Journal of Statistical Software, 40(8), 1-18.", - "URL http://www.jstatsoft.org/v40/i08/.") -) - -citEntry(entry = "Book", +bibentry("Book", title = "Seamless {R} and {C++} Integration with {Rcpp}", - author = personList(as.person("Dirk Eddelbuettel")), + author = person("Dirk", "Eddelbuettel", + email = "edd@debian.org", + comment = c(ORCID = "0000-0001-6419-907X")), publisher = "Springer", address = "New York", year = 2013, note = "ISBN 978-1-4614-6867-7", - doi = "10.1007/978-1-4614-6868-4", - - textVersion = paste("Eddelbuettel, Dirk (2013)", - "Seamless R and C++ Integration with Rcpp.", - "Springer, New York. ISBN 978-1-4614-6867-7.") -) - -citEntry(entry = "Article", - title = "{Extending \textit{R} with \textit{C++}: A Brief Introduction to \textit{Rcpp}}", - author = personList(as.person("Dirk Eddelbuettel"), - as.person("James Joseph Balamuta")), - journal = "PeerJ Preprints", - year = "2017", - month = "aug", - volume = "5", - pages = "e3188v1", - issn = "2167-9843", - url = "https://doi.org/10.7287/peerj.preprints.3188v1", - doi = "10.7287/peerj.preprints.3188v1", + doi = "10.1007/978-1-4614-6868-4") - textVersion = paste("Dirk Eddelbuettel and James Joseph Balamuta (2017).", - "Extending R with C++: A Brief Introduction to Rcpp.", - "PeerJ Preprints 5:e3188v1.", - "URL https://doi.org/10.7287/peerj.preprints.3188v1.") -) +bibentry("Article", + title = "{Extending {R} with {C++}: A Brief Introduction to {Rcpp}}", + author = c(person("Dirk", "Eddelbuettel", + email = "edd@debian.org", + comment = c(ORCID = "0000-0001-6419-907X")), + person("James Joseph", "Balamuta", + email = "balamut2@illinois.edu", + comment = c(ORCID = "0000-0003-2826-8458"))), + journal = "The American Statistician", + year = "2018", + volume = "72", + number = "1", + pages = "28-36", + doi = "10.1080/00031305.2017.1375990") diff --git a/inst/NEWS.Rd b/inst/NEWS.Rd index 55a698462..f77d7d30b 100644 --- a/inst/NEWS.Rd +++ b/inst/NEWS.Rd @@ -3,8 +3,676 @@ \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 version 0.12.20 (2018-11-xx)}{ +\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: + \itemize{ + \item Set R_NO_REMAP if not already defined (Dirk in \ghpr{1296}) + \item Add variadic templates to be used instead of generated code + (Andrew Johnson in \ghpr{1303}) + \item Count variables were switches to \code{size_t} to avoid warnings + about conversion-narrowing (Dirk in \ghpr{1307}) + \item Rcpp now avoids the usage of the (non-API) DATAPTR function when + accessing the contents of Rcpp Vector objects where possible. (Kevin in + \ghpr{1310}) + \item Rcpp now emits an R warning on out-of-bounds Vector accesses. This + may become an error in a future Rcpp release. (Kevin in \ghpr{1310}) + \item Switch \code{VECTOR_PTR} and \code{STRING_PTR} to new API-compliant + \code{RO} variants (Kevin in \ghpr{1317} fixing \ghit{1316}) + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Small updates to the CI test containers have been made (\ghpr{1304}) + } + } +} + +\section{Changes in Rcpp release version 1.0.12 (2024-01-08)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Missing header includes as spotted by some recent tools were + added in two places (Michael Chirico in \ghpr{1272} closing + \ghit{1271}). + \item Casts to avoid integer overflow in matrix row/col selections + 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 + (Dirk in \ghpr{1288} fixing \ghit{1287}). + \item The upcoming \code{OBJSXP} addition to R 4.4.0 is supported in + the \code{type2name} mapper (Dirk and Iñaki in \ghpr{1293}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item Generated interface code from base R that fails under LTO is now + corrected (Iñaki in \ghpr{1274} fixing a StackOverflow issue). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The caption for third figure in the introductory vignette has + been corrected (Dirk in \ghpr{1277} fixing \ghit{1276}). + \item A small formatting issue was correct in an Rd file as + noticed by R-devel (Dirk in \ghpr{1282}). + \item The Rcpp FAQ vignette has been updated (Dirk in \ghpr{1284}). + \item The \code{Rcpp.bib} file has been refreshed to current package + versions. + } + \item Changes in Rcpp Deployment: + \itemize{ + \item The RcppExports file for an included test package has been + updated (Dirk in \ghpr{1289}). + } + } +} + +\section{Changes in Rcpp release version 1.0.11 (2023-07-03)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item \code{Rcpp:::CxxFlags()} now quotes only non-standard include path + on linux (Lukasz in \ghpr{1243} closing \ghit{1242}). + \item Two unit tests no longer accidentally bark on stdout (Dirk and + Iñaki in \ghpr{1245}). + \item Compilation under C++20 using \pkg{clang++} and its standard + library is enabled (Dirk in \ghpr{1248} closing \ghit{1244}). + \item Use backticks in a generated \code{.Call()} statement in + \code{RcppExports.R} (Dirk \ghpr{1256} closing \ghit{1255}). + \item Switch to \code{system2()} to capture standard error messages in + error cases (Iñaki in \ghpr{1259} and \ghpr{1261} fixing \ghit{1257}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The CITATION file format has been updated (Dirk in \ghpr{1250} + fixing \ghit{1249}). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item A test for \code{qnorm} now uses the more accurate value from R + 4.3.0 (Dirk in \ghpr{1252} and \ghpr{1260} fixing \ghit{1251}). + \item Skip tests with path issues on Windows (Iñaki in \ghpr{1258}). + \item Container deployment in continuous integrations was + improved. (Iñaki and Dirk in \ghpr{1264}, Dirk in \ghpr{1269}). + \item Several files receives minor edits to please \code{R CMD check} + from r-devel (Dirk in \ghpr{1267}). + } + } +} + +\section{Changes in Rcpp release version 1.0.10 (2023-01-12)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Unwind protection is enabled by default (Iñaki in \ghpr{1225}). + It can be disabled by defining \code{RCPP_NO_UNWIND_PROTECT} before + including \code{Rcpp.h}. \code{RCPP_USE_UNWIND_PROTECT} is not checked + anymore and has no effect. The associated plugin \code{unwindProtect} + is therefore deprecated and will be removed in a future release. + \item The 'finalize' method for Rcpp Modules is now eagerly materialized, + fixing an issue where errors can occur when Module finalizers are run + (Kevin in \ghpr{1231} closing \ghit{1230}). + \item Zero-row \code{data.frame} objects can receive \code{push_back} + or \code{push_front} (Dirk in \ghpr{1233} fixing \ghit{1232}). + \item One remaining \code{sprintf} has been replaced by + \code{snprintf} (Dirk and Kevin in \ghpr{1236} and \ghpr{1237}). + \item Several conversion warnings found by \code{clang++} have been + addressed (Dirk in \ghpr{1240} and \ghpr{1241}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item The C++20, C++2b (experimental) and C++23 standards now have + plugin support like the other C++ standards (Dirk in \ghpr{1228}). + \item The source path for attributes received one more protection + from spaces (Dirk in \ghpr{1235} addressing \ghit{1234}). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Several GitHub Actions have been updated. + } + } +} + +\section{Changes in Rcpp release version 1.0.9 (2022-07-02)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Accomodate C++98 compilation by adjusting attributes.cpp (Dirk in + \ghpr{1193} fixing \ghit{1192}) + \item Accomodate newest compilers replacing deprecated + \code{std::unary_function} and \code{std::binary_function} with + \code{std::function} (Dirk in \ghpr{1202} fixing \ghit{1201} and + CRAN request) + \item Upon removal from precious list, the tag is set to null + (Iñaki in \ghpr{1205} fixing \ghit{1203}) + \item Move constructor and assignment for strings have been added + (Dean Scarff in \ghpr{1219}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item Adjust one overflowing column (Bill Denney in \ghpr{1196} fixing + \ghit{1195}) + \item Correct a typo in the FAQ (Marco Colombo in \ghpr{1217}) + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Accomodate four digit version numbers in unit test (Dirk) + \item Do not run complete test suite to limit test time to CRAN + preference (Dirk in \ghpr{1206}) + \item Small updates to the CI test containers have been made + \item Some of changes also applied to an interim release + 1.0.8.3 made for CRAN on 2022-03-14. + } + } +} + +\section{Changes in Rcpp release version 1.0.8 (2022-01-11)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item \code{STRICT_R_HEADERS} is now enabled by default, see + extensive discussion in \ghit{1158} closing \ghit{898}. + \item A new \code{#define} allows default setting of finalizer + calls for external pointers (Iñaki in \ghpr{1180} closing \ghit{1108}). + \item \code{Rcpp:::CxxFlags()} now quotes the include path generated, + (Kevin in \ghpr{1189} closing \ghit{1188}). + \item New header files \code{Rcpp/Light}, \code{Rcpp/Lighter}, + \code{Rcpp/Lightest} and default \code{Rcpp/Rcpp} for fine-grained + access to features (and compilation time) (Dirk \ghpr{1191} + addressing \ghpr{1168}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item A new option \code{signature} allows customization of + function signatures (Travers Ching in \ghpr{1184} and \ghpr{1187} fixing + \ghit{1182}) + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The Rcpp FAQ has a new entry on how \emph{not} to grow a vector + (Dirk in \ghpr{1167}). + \item Some long-spurious calls to \code{RNGSope} have been removed + from examples (Dirk in \ghpr{1173} closing \ghit{1172}). + \item DOI reference in the bibtex files have been updated per JSS + request (Dirk in \ghpr{1186}). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Some continuous integration components have been updated + (Dirk in \ghpr{1174}, \ghpr{1181}, and \ghpr{1190}). + } + } +} + +\section{Changes in Rcpp release version 1.0.7 (2021-07-06)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Refactored \code{Rcpp_PreserveObject} and \code{Rcpp_ReleaseObject} + which are now O(1) (Dirk and Iñaki in \ghpr{1133} and \ghpr{1135} + fixing \ghit{382} and \ghit{1081}). + \item A spuriously assigned variable was removed (Dirk in + \ghpr{1138} fixing \ghit{1137}). + \item Global \code{Rcout} and \code{Rcerr} objects are supported + via a compiler directive (Iñaki in \ghpr{1139} fixing \ghit{928}) + \item Add support for \code{Rcpp::message} (Dirk in \ghpr{1146} + fixing \ghit{1145}). + \item The \code{uint32_t} type is used throughout instead of + \code{unsigned int} (Dirk in \ghpr{1153} fixing \ghit{1152}). + \item The \code{cfloat} header for floating point limits is now + included (Dirk in \ghpr{1162} fixing \ghit{1161}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item Packages with dots in their name can now have per-package + include files (Dirk in \ghpr{1132} fixing \ghit{1129}). + \item New argument \code{echo} to quieten optional evaluation in + \code{sourceCpp} (Dirk in \ghpr{1138} fixing \ghit{1126}). + } + \item Forthcoming Changes in Rcpp API: + \itemize{ + \item Starting with Rcpp 1.0.8 anticipated in January 2022, + \code{STRICT_R_HEADERS} will be enabled by default, see \ghit{1126}. + } + } +} + +\section{Changes in Rcpp release version 1.0.6 (2021-01-14)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Replace remaining few uses of \code{EXTPTR_PTR} with + \code{R_ExternalPtrAddr} (Kevin in \ghpr{1098} fixing + \ghit{1097}). + \item Add \code{push_back} and \code{push_front} for + \code{DataFrame} (Walter Somerville in \ghpr{1099} fixing + \ghit{1094}). + \item Remove a misleading-to-wrong comment (Mattias Ellert in + \ghpr{1109} cleaning up after \ghpr{1049}). + \item Address a sanitizer report by initializing two private + \code{bool} variables (Benjamin Christoffersen in \ghpr{1113}). + \item External pointer finalizer toggle default values were + corrected to true (Dirk in \ghpr{1115}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item Several URLs were updated to https and/or new addresses (Dirk). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Added GitHub Actions CI using the same container-based setup + used previously, and also carried code coverage over (Dirk in + \ghpr{1128}). + } + \item Changes in Rcpp support functions: + \itemize{ + \item \code{Rcpp.package.skeleton()} avoids warning from R. (Dirk) + } + } +} + +\section{Changes in Rcpp release version 1.0.5 (2020-07-01)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item The exception handler code in \ghpr{1043} was updated to ensure + proper include behavior (Kevin in \ghpr{1047} fixing \ghit{1046}). + \item A missing \code{Rcpp_list6} definition was added to support + R 3.3.* builds (Davis Vaughan in \ghpr{1049} fixing \ghit{1048}). + \item Missing \code{Rcpp_list{2,3,4,5}} definition were added to + the Rcpp namespace (Dirk in \ghpr{1054} fixing \ghit{1053}). + \item A further updated corrected the header include and provided + a missing else branch (Mattias Ellert in \ghpr{1055}). + \item Two more assignments are protected with \code{Rcpp::Shield} + (Dirk in \ghpr{1059}). + \item One call to \code{abs} is now properly namespaced with + \code{std::} (Uwe Korn in \ghpr{1069}). + \item String object memory preservation was corrected/simplified + (Kevin in \ghpr{1082}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item Empty strings are not passed to \code{R CMD SHLIB} which was + seen with R 4.0.0 on Windows (Kevin in \ghpr{1062} fixing + \ghpr{1061}). + \item The \code{short_file_name()} helper function is safer with + respect to temporaries (Kevin in \ghpr{1067} fixing \ghit{1066}, + and \ghpr{1071} fixing \ghpr{1070}). + } + \item Changes in Rcpp Sugar: + \itemize{ + \item Two \code{sample()} objects are now standard vectors and not + \code{R_alloc} created (Dirk in \ghpr{1075} fixing \ghpr{1074}). + } + \item Changes in Rcpp support functions: + \itemize{ + \item \code{Rcpp.package.skeleton()} adjusts for a (documented) + change in R 4.0.0 (Dirk in \ghpr{1088} fixing \ghpr{1087}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The pdf file of the earlier introduction is again typeset + with bibliographic information (Dirk). + \item A new vignette describing how to package C++ libraries has + been added (Dirk in \ghpr{1078} fixing \ghit{1077}). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Travis CI unit tests now run a matrix over the versions of R + also tested at CRAN (rel/dev/oldrel/oldoldrel), and coverage runs + in parallel for a net speed-up (Dirk in \ghpr{1056} and + \ghpr{1057}). + \item The exceptions test is now partially skipped on Solaris as + it already is on Windows (Dirk in \ghpr{1065}). + \item The default CI runner was upgraded to R 4.0.0 (Dirk). + \item The CI matrix spans R 3.5, 3.6, r-release and r-devel (Dirk). + } + } +} + +\section{Changes in Rcpp version 1.0.4 (2020-03-13)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Safer \code{Rcpp_list*}, \code{Rcpp_lang*} and + \code{Function.operator()} (Romain in \ghpr{1014}, \ghit{1015}). + \item A number of \code{#nocov} markers were added (Dirk in + \ghpr{1036}, \ghpr{1042} and \ghpr{1044}). + \item Finalizer calls clear external pointer first (Kirill Müller and + Dirk in \ghpr{1038}). + \item Scalar operations with a rhs matrix no longer change the + matrix value (Qiang in \ghpr{1040} fixing (again) \ghit{365}). + \item \code{Rcpp::exception} and \code{Rcpp::stop} are now more + thread-safe (Joshua Pritikin in \ghpr{1043}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item The \code{cppFunction} helper now deals correctly with mulitple + \code{depends} arguments (TJ McKinley in \ghpr{1016} fixing + \ghit{1017}). + \item Invisible return objects are now supported via new option (Kun Ren + in \ghpr{1025} fixing \ghit{1024}). + \item Unavailable packages referred to in \code{LinkingTo} are now + reported (Dirk in \ghpr{1027} fixing \ghit{1026}). + \item The \code{sourceCpp} function can now create a debug DLL on + Windows (Dirk in \ghpr{1037} fixing \ghit{1035}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The \code{.github/} directory now has more explicit guidance on + contributing, issues, and pull requests (Dirk). + \item The Rcpp Attributes vignette describe the new invisible return + object option (Kun Ren in \ghpr{1025}). + \item Vignettes are now included as pre-made pdf files (Dirk in \ghpr{1029}) + \item The Rcpp FAQ has a new entry on the recommended + \code{importFrom} directive (Dirk in \ghpr{1031} fixing \ghit{1030}). + \item The bib file for the vignette was once again updated to + current package versions (Dirk). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Added unit test to check if C++ version remains remains aligned + with the package number (Dirk in \ghpr{1022} fixing \ghit{1021}). + \item The unit test system was switched to tinytest (Dirk in + \ghpr{1028}, \ghpr{1032}, \ghpr{1033}). + } + } +} + +\section{Changes in Rcpp version 1.0.3 (2019-11-08)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Compilation can be sped up by skipping Modules headers via a + toggle \code{RCPP_NO_MODULES} (Kevin in \ghpr{995} for \ghit{993}). + \item Compilation can be sped up by toggling \code{RCPP_NO_RTTI} which + implies \code{RCPP_NO_MODULES} (Dirk in \ghpr{998} fixing \ghit{997}). + \item \code{XPtr} tags are now preserved in \code{as<>} (Stephen Wade + in \ghpr{1003} fixing \ghit{986}, plus Dirk in \ghpr{1012}). + \item A few more temporary allocations are now protected from garbage + collection (Romain Francois in \ghpr{1010}, and Dirk in \ghpr{1011}). + } + \item Changes in Rcpp Modules: + \itemize{ + \item Improved initialization via explicit \code{Rcpp::} prefix + (Riccardo Porreca in \ghpr{980}). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item A unit test for Rcpp Class exposure was updated to not fail under + r-devel (Dirk in \ghpr{1008} fixing \ghit{1006}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The \code{Rcpp-modules} vignette received a major review and + edit (Riccardo Porreca in \ghpr{982}). + \item Minor whitespace alignments and edits were made in three + vignettes following the new \pkg{pinp} release (Dirk). + \item New badges for DOI and CRAN and BioConductor reverse dependencies + have been added to README.md (Dirk). + \item Vignettes are now included pre-made (Dirk in \ghpr{1005} + addressing \ghit{1004})). + \item The Rcpp FAQ has two new entries on 'no modules / no rtti' and + exceptions across shared libraries (Dirk in \ghpr{1009}). + } + } +} + +\section{Changes in Rcpp version 1.0.2 (2019-07-20)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Files in \code{src/} are now consistentely lowercase (Dirk + in \ghpr{956}). + \item The Rcpp 'API Version' is now accessible via + \code{getRcppVersion()} (Dirk in \ghpr{963}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item The second END wrapper macro also gets \code{UNPROTECT} and + a variable reference suppressing compiler warnings (Dirk in + \ghpr{953} fixing \ghit{951}). + \item Default function arguments are parsed correctly (Pierrick + Roger in \ghpr{977} fixing \ghit{975}) + } + \item Changes in Rcpp Sugar: + \itemize{ + \item Added decreasing parameter to \code{sort_unique()} + (James Balamuta in \ghpr{958} addressing \ghit{950}). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Travis CI unit tests are now always running irrespective of + the package version (Dirk in \ghpr{954}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item The \code{Rcpp-modules} vignette now covers the + \code{RCPP_EXPOSED_*} macros, and the \code{Rcpp-extending} vignette + references it (Ralf Stubner in \ghpr{959} fixing \ghit{952}). + } + } +} + +\section{Changes in Rcpp version 1.0.1 (2019-03-17)}{ + \itemize{ + \item Changes in Rcpp API: + \itemize{ + \item Subsetting is no longer limited by an integer range (William + Nolan in \ghpr{920} fixing \ghit{919}). + \item Error messages from subsetting are now more informative + (Qiang and Dirk). + \item \code{Shelter} increases count only on non-null objects + (Dirk in \ghpr{940} as suggested by Stepan Sindelar in \ghit{935}). + \item \code{AttributeProxy::set()} and a few related setters get + \code{Shield<>} to ensure \code{rchk} is happy (Romain in \ghpr{947} + fixing \ghit{946}). + } + \item Changes in Rcpp Attributes: + \itemize{ + \item A new plugin was added for C++20 (Dirk in \ghpr{927}) + \item Fixed an issue where 'stale' symbols could become registered in + RcppExports.cpp, leading to linker errors and other related issues + (Kevin in \ghpr{939} fixing \ghit{733} and \ghit{934}). + \item The wrapper macro gets an \code{UNPROTECT} to ensure \code{rchk} + is happy (Romain in \ghpr{949}) fixing \ghit{948}). + } + \item Changes in Rcpp Documentation: + \itemize{ + \item Three small corrections were added in the 'Rcpp Quickref' + vignette (Zhuoer Dong in \ghpr{933} fixing \ghit{932}). + \item The \code{Rcpp-modules} vignette now has documentation for + \code{.factory} (Ralf Stubner in \ghpr{938} fixing \ghit{937}). + } + \item Changes in Rcpp Deployment: + \itemize{ + \item Travis CI again reports to CodeCov.io (Dirk and Ralf Stubner in + \ghpr{942} fixing \ghit{941}). + } + } +} + +\section{Changes in Rcpp version 1.0.0 (2018-11-05)}{ + \itemize{ + \item Happy tenth birthday to Rcpp, and hello release 1.0 ! \item Changes in Rcpp API: \itemize{ \item The empty destructor for the \code{Date} class was removed @@ -12,6 +680,9 @@ \item The constructor for \code{NumericMatrix(not_init(n,k))} was corrected (Romain in \ghpr{904}, Dirk in \ghpr{905}, and also Romain in \ghpr{908} fixing \ghpr{907}). + \item \code{Rcpp::String} no longer silently drops embedded + \code{NUL} bytes in strings but throws new Rcpp exception + \code{embedded_nul_in_string}. (Kevin in \ghpr{917} fixing \ghit{916}). } \item Changes in Rcpp Deployment: \itemize{ @@ -21,13 +692,19 @@ } \item Changes in Rcpp Attributes: \itemize{ + \item A new \code{[[Rcpp::init]]} attribute allows function + registration for running on package initialization (JJ in + \ghpr{903}). \item Sort the files scanned for attributes in the C locale for - stable output across systems. + stable output across systems (JJ in \ghpr{912}). } \item Changes in Rcpp Documentation: \itemize{ \item The 'Rcpp Extending' vignette was corrected and refers to - \code{EXPOSED} rather than \code{EXPORTED} (Ralf Stubner in \ghpr{910}). + \code{EXPOSED} rather than \code{EXPORTED} (Ralf Stubner in + \ghpr{910}). + \item The 'Unit test' vignette is no longer included (Dirk in + \ghpr{914}). } } } @@ -38,7 +715,7 @@ \itemize{ \item The \code{no_init()} accessor for vectors and matrices is now wrapped in \code{Shield<>()} to not trigger \code{rchk} - warnings (Kirill Mueller in \ghpr{893} addressing \ghit{892}). + warnings (Kirill Müller in \ghpr{893} addressing \ghit{892}). \item \code{STRICT_R_HEADERS} will be defined twelve months from now; until then we protect it via \code{RCPP_NO_STRICT_HEADERS} which can then be used to avoid the definition; downstream @@ -129,12 +806,12 @@ \itemize{ \item Changes in Rcpp API: \itemize{ - \item The random number \code{Generator} class no longer inhreits from + \item The random number \code{Generator} class no longer inherits from \code{RNGScope} (Kevin in \ghpr{837} fixing \ghit{836}). - \item A new class, \code{SuspendRNGSynchronizationScope}, can be created - and used to ensure that calls to Rcpp functions do not attempt to call - \code{::GetRNGstate()} or \code{::PutRNGstate()} for the duration of - some code block. + \item A new class, \code{SuspendRNGSynchronizationScope}, can be created + and used to ensure that calls to Rcpp functions do not attempt to call + \code{::GetRNGstate()} or \code{::PutRNGstate()} for the duration of + some code block. \item A spurious parenthesis was removed to please gcc8 (Dirk fixing \ghit{841}) \item The optional \code{Timer} class header now undefines @@ -173,7 +850,7 @@ \item Changes in Rcpp Attributes: \itemize{ \item Code generated with \code{cppFunction()} now uses \code{.Call()} - directly (Kirill Mueller in \ghpr{813} addressing \ghit{795}). + directly (Kirill Müller in \ghpr{813} addressing \ghit{795}). } \item Changes in Rcpp Documentation: \itemize{ @@ -343,7 +1020,7 @@ \item Rcpp::exceptions can now be constructed without a call stack (Jim Hester in \ghpr{663} addressing \ghit{664}). \item Somewhat spurious compiler messages under very verbose settings are - now suppressed (Kirill Mueller in \ghpr{670}, \ghpr{671}, \ghpr{672}, + now suppressed (Kirill Müller in \ghpr{670}, \ghpr{671}, \ghpr{672}, \ghpr{687}, \ghpr{688}, \ghpr{691}). \item Refreshed the included \code{tinyformat} template library (James Balamuta in \ghpr{674} addressing \ghit{673}). @@ -649,7 +1326,7 @@ \code{Nullable} class (Dan in PR \ghpr{423} closing \ghit{421}) \item The \code{Nullable<>::operator SEXP()} and \code{Nullable<>::get()} now also work for \code{const} objects - (Kirill Mueller in PR \ghpr{417}). + (Kirill Müller in PR \ghpr{417}). \item A subsetting error was fixed (Qiang via \ghpr{432} closing \ghit{431}). } @@ -1321,8 +1998,7 @@ } \item Changes in Rcpp sugar: \itemize{ - \item New function \code{na_omit} based on the StackOverflow thread - \url{http://stackoverflow.com/questions/15953768/} + \item New function \code{na_omit} based on a StackOverflow thread \item New function \code{is_finite} and \code{is_infinite} that reproduces the behavior of R's \code{is.finite} and \code{is.infinite} functions diff --git a/inst/bib/Rcpp.bib b/inst/bib/Rcpp.bib index 92f680009..4c2a6af37 100644 --- a/inst/bib/Rcpp.bib +++ b/inst/bib/Rcpp.bib @@ -1,15 +1,16 @@ -@String{CRAN = "http://CRAN.R-Project.org/" } +@String{CRAN = "https://CRAN.R-Project.org/" } @String{manuals = CRAN # "doc/manuals/" } @String{RCoreTeam = "{R Core Team}" } @String{RFoundation = "R Foundation for Statistical Computing" } -@String{R-Forge = "http://R-Forge.R-Project.org/" } +@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 = "http://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, @@ -39,7 +40,7 @@ @Manual{Armstrong:2009:RAbstraction author = {Whit Armstrong}, year = 2009, note = {Code repository last updated 2009-07-22.}, - url = {http://github.com/armstrtw/rabstraction} + url = {https://github.com/armstrtw/rabstraction} } @Manual{Armstrong:2009:RObjects, @@ -48,7 +49,7 @@ @Manual{Armstrong:2009:RObjects author = {Whit Armstrong}, year = 2009, note = {Code repository last updated 2009-11-28.}, - url = {http://github.com/armstrtw/RObjects} + url = {https://github.com/armstrtw/RObjects} } @InProceedings{Bates+DebRoy:2001:C++Classes, @@ -59,7 +60,7 @@ @InProceedings{Bates+DebRoy:2001:C++Classes Universit\"at Wien, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch}, year = {2001}, - url = {http://www.ci.tuwien.ac.at/Conferences/DSC-2001/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2001/Proceedings/}, note = {ISSN 1609-395X} } @@ -69,48 +70,81 @@ @Misc{Brokken:2011:Cpp title = {C++ Annotations}, howpublished = {Electronic book, University of Groningen}, year = 2011, - url = {http://www.icce.rug.nl/documents/cplusplus/} + url = {https://www.icce.rug.nl/documents/cplusplus/} +} + +@Manual{CRAN:anytime, + title = {anytime: Anything to 'POSIXct' or 'Date' Converter}, + author = {Dirk Eddelbuettel}, + 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 = {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 = 2018, - note = {R package version 1.2-14}, - url = CRAN # "package=Matrix" + year = 2025, + note = {R package version 1.7-4}, + 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 = 2017, - note = {R package version 0.2.14}, - 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 = 2018, - note = {R package version 0.4.12}, - 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}, - author = {Dirk Eddelbuettel and Khanh Nguyen}, - year = 2017, - note = {R package version 0.4.4}, - url = CRAN # "package=RQuantLib" + title = {RQuantLib: {R} Interface to the {QuantLib} Library}, + author = {Dirk Eddelbuettel and Khanh Nguyen and Terry Leitch}, + 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 = 2015, - note = {R package version 0.4.31}, - url = {https://CRAN.R-project.org/package=RUnit}, + year = 2024, + note = {R package version 0.4.33.1}, + oldurl = CRAN # "package=RUnit", + doi = DOI # "RUnit" } @Manual{CRAN:Rcpp, @@ -118,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 = 2018, - note = {R package version 0.12.19}, - url = CRAN # "package=Rcpp" + year = 2026, + note = {R package version 1.1.1}, + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Attributes, @@ -128,113 +163,163 @@ @Manual{CRAN:Rcpp:Attributes author = {J. J. Allaire and Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {{Rcpp} Attributes}, - year = 2018, + 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 = 2018, + 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 = 2026, + note = {Vignette included in R 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 = 2018, + 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 = 2018, + 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 = 2018, + 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}, - year = 2018, - note = {R package version 0.9.100.4.0}, - url = CRAN # "package=RcppArmadillo" + Douglas Bates and Binxiang Ni and Conrad Sanderson}, + 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 = 2024, + note = {R package version 0.2.13}, + oldurl = CRAN # "package=RcppCCTZ", + doi = DOI # "RcppCCTZ" } @Manual{CRAN:RcppClassic, title = {RcppClassic: Deprecated 'classic' Rcpp API}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2018, - note = {R package version 0.9.11}, - url = CRAN # "package=RcppClassic" + year = 2022, + note = {R package version 0.9.13}, + 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 = 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 = 2018, - note = {R package version 0.1.6}, - url = CRAN # "package=RcppDE" + year = 2025, + note = {R package version 0.1.8}, + 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 = 2018, - note = {{R} package version 0.3.3.4.0}, - 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 = 2016, - note = {R package version 0.1.8}, - 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 = 2018, - note = {R package version 0.3.6}, - url = CRAN # "package=RcppGSL" + year = 2023, + note = {R package version 0.3.13}, + 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 = 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 = 2018, - note = {R package version 0.1.5}, - 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 = 2013, - note = {R package version 1.7-3}, - url = CRAN # "package=Rserve" + year = 2025, + note = {R package version 1.8-16}, + oldurl = CRAN # "package=Rserve", + doi = DOI # "Rserve" } @Manual{CRAN:cxxPack, @@ -243,68 +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 Winston Chang}, - year = 2016, - note = {R package version 1.12.0}, - url = {https://CRAN.R-project.org/package=devtools}, + author = {Hadley Wickham and Jim Hester and Winston Chang}, + year = 2025, + note = {R package version 2.4.6}, + oldurl = CRAN # "package=devtools", + doi = DOI # "devtools" } @Manual{CRAN:highlight, - title = {highlight: Syntax highlighter}, - author = {Romain Fran\c{c}ois}, - year = 2017, - note = {R package with version 0.4.7.2}, - url = CRAN # "package=highlight" + title = {highlight: Syntax Highlighter}, + author = {Hadley Wickham and Romain Fran\c{c}ois and Andre Simon}, + 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}, - year = 2015, - note = {R package version 0.3.14}, - url = CRAN # "package=inline" + 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 = 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 = 2017, - note = {R package version 0.3.2}, - 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 = 2015, - note = {R package version 1.4-2.1}, - url = {https://CRAN.R-project.org/package=microbenchmark} + year = 2023, + 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 = 2014, - note = {R package version 1.2.4}, - 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 = {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}, - year = 2017, - note = {R package version 0.3.3}, - url = {https://CRAN.R-project.org/package=profvis}, + author = {Winston Chang and Javier Luraschi and and Timothy Mastny}, + year = 2024, + note = {R package version 0.4.0}, + oldurl = CRAN # "package=profvis", + doi = DOI # "profvis" } @Manual{CRAN:rbenchmark, @@ -312,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}, - author = {Hadley Wickham and Peter Danenberg and Manuel Eugster}, - year = 2017, - note = {R package version 6.0.1}, - url = CRAN # "package=roxygen2" + title = {roxygen2: In-Line documentation for R}, + author = {Hadley Wickham and Peter Danenberg and G\a'bor Cs\a'rdi and Manuel Eugster}, + year = 2025, + note = {R package version 7.3.3}, + oldurl = CRAN # "package=roxygen2", + doi = DOI # "roxygen2" } @Article{CRAN:testthat, @@ -361,14 +467,33 @@ @Book{Chambers:2016:ExtR note = {{ISBN} 9781498775717} } +@Article{Chambers:2020:S+R+DS, + author = {Chambers, John M.}, + title = {S, R, and Data Science}, + year = 2020, + issue_date = {June 2020}, + publisher = {Association for Computing Machinery}, + address = {New York, NY, USA}, + volume = 4, + number = {HOPL}, + url = {https://doi.org/10.1145/3386334}, + doi = {10.1145/3386334}, + journal = {Proceeding of the ACM on Programming Languages}, + month = jun, + articleno = 84, + numpages = 17, + keywords = {data science, statistical computing, scientific + computing} +} + @Misc{Cpp11, author = "ISO/IEC", organization = "{International Organization for Standardization}", title = "\proglang{C++} 2011 Standard Document 14882:2011", howpublished = {ISO/IEC Standard Group for Information Technology / Programming Languages / C++}, year = 2011, - url = "http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372", - urlansi = "http://webstore.ansi.org/RecordDetail.aspx?sku=ISO/IEC%2014882:2011" + url = "https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372", + urlansi = "https://webstore.ansi.org/RecordDetail.aspx?sku=ISO/IEC%2014882:2011" } @book{Dongarra:1979:UGLINPACK, @@ -388,7 +513,7 @@ @Article{Eddelbuettel+Sanderson:2013:RcppArmadillo month = {March}, pages = {1054--1063}, doi = {10.1016/j.csda.2013.02.005}, - url = {http://dx.doi.org/10.1016/j.csda.2013.02.005} + url = {https://dx.doi.org/10.1016/j.csda.2013.02.005} } @Article{Eddelbuettel+Sanderson:2014:RcppArmadillo, @@ -400,7 +525,7 @@ @Article{Eddelbuettel+Sanderson:2014:RcppArmadillo month = {March}, pages = {1054--1063}, doi = {10.1016/j.csda.2013.02.005}, - url = {http://dx.doi.org/10.1016/j.csda.2013.02.005} + url = {https://dx.doi.org/10.1016/j.csda.2013.02.005} } @Book{Eddelbuettel:2013:Rcpp, @@ -414,7 +539,7 @@ @Book{Eddelbuettel:2013:Rcpp } @article{Efron:1979:Bootstrap, - URL = {http://www.jstor.org/stable/2958830}, + URL = {https://www.jstor.org/stable/2958830}, author = {Efron, B.}, journal = {The Annals of Statistics}, number = {1}, @@ -429,10 +554,8 @@ @MISC{Eigen:Web author = {Ga\"{e}l Guennebaud and Beno\^{i}t Jacob and others}, title = {Eigen v3}, year = 2012, - url = {http://eigen.tuxfamily.org}, + url = {https://libeigen.gitlib.io/} } -; see http://eigen.tuxfamily.org/index.php?title=BibTeX -; replaced 'howpublished' with 'url' and updated year to 2011, and again to 2012 @Manual{GSL, title = {{GNU} {S}cientific {L}ibrary {R}eference {M}anual}, @@ -440,7 +563,7 @@ @Manual{GSL year = {2010}, edition = {3rd}, note = {Version 1.14. {ISBN} 0954612078}, - url = {http://www.gnu.org/software/gsl} + url = {https://www.gnu.org/software/gsl} } @Book{Gentleman:2009:RProgramming, @@ -464,7 +587,8 @@ @Article{Gropp+Lusk+Doss+Skjellum:1996:MPI title = {A high-performance, portable implementation of the {MPI} message passing interface standard}, journal = {Parallel Computing}, year = 1996, - url = {http://dx.doi.org/10.1016/0167-8191(96)00024-5}, + url = {https://dx.doi.org/10.1016/0167-8191(96)00024-5}, + doi = {10.1016/0167-8191(96)00024-5}, volume = 22, number = 6, pages = {789--828} @@ -513,7 +637,8 @@ @Article{JSS:RProtoBuf volume = {71}, number = {2}, pages = {1--24}, - doi = {10.18637/jss.v071.i02}, + url = {https://doi.org/10.18637/jss.v071.i02}, + doi = {10.18637/jss.v071.i02} } @Article{JSS:Rcpp, @@ -524,7 +649,8 @@ @Article{JSS:Rcpp volume = 40, number = 8, pages = {1--18}, - url = {http://www.jstatsoft.org/v40/i08/}, + url = {https://doi.org/10.18637/jss.v040.i08}, + doi = {10.18637/jss.v040.i08} } @Article{JSS:RcppEigen, @@ -536,7 +662,8 @@ @Article{JSS:RcppEigen volume = {52}, number = {5}, pages = {1--24}, - url = {http://www.jstatsoft.org/v52/i05/}, + url = {https://doi.org/10.18637/jss.v052.i05}, + doi = {10.18637/jss.v052.i05} } @Unpublished{Java+Gaile+Manly:2007:RCpp, @@ -546,7 +673,7 @@ @Unpublished{Java+Gaile+Manly:2007:RCpp Objects in {C++} Extensions}, note = {Unpublished manuscript, University at Buffalo}, url = - {http://sphhp.buffalo.edu/biostat/research/techreports/UB_Biostatistics_TR0702.pdf}, + {https://sphhp.buffalo.edu/biostat/research/techreports/UB_Biostatistics_TR0702.pdf}, month = {July}, year = 2007 } @@ -554,7 +681,7 @@ @Unpublished{Java+Gaile+Manly:2007:RCpp @misc{KDE-TechBase:2012, author = {KDE-TechBase}, title = {Binary Compatibility Issues With {C++}}, - url = "http://techbase.kde.org/Policies/Binary_Compatibility_Issues_With_C++", + url = "https://techbase.kde.org/Policies/Binary_Compatibility_Issues_With_C++", year = 2012, note = "[Online; accessed 24-November-2012]" } @@ -603,7 +730,7 @@ @InProceedings{Maurer+Wong:2008:AttributesInC++ booktitle = {JTC1/SC22/WG21 - The C++ Standards Committee}, year = {2008}, url = - {http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}, + {https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}, note = {{N2761=08-0271}} } @@ -646,7 +773,8 @@ @Article{PeerJ:Rcpp issue = {e3188v1}, year = 2017, month = {August}, - doi = {10.7287/peerj.preprints.3188v1/}, + url = {https://peerj.com/preprints/3188v1/}, + doi = {10.7287/peerj.preprints.3188v1} } @Book{Plauger+Et+Al:2000:STL, @@ -655,16 +783,24 @@ @Book{Plauger+Et+Al:2000:STL title = {The {C++} Standard Template Library}, publisher = {Prentice Hall PTR}, year = 2000, - note = {{ISBN} 978-0134376332}, + note = {{ISBN} 978-0134376332} +} + +@manual{QuantLib, + author = {{QuantLib Core Team}}, + year = 2021, + title = {QuantLib: a free/open-source library for quantitative finance}, + url = {https://www.quantlib.org} } @manual{R:Administration, author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "R Installation and Administration", annote = {{ISBN} 3-900051-09-7}, + doi = "10.32614/R.manuals", url = manuals # "R-admin.html" } @@ -672,9 +808,10 @@ @manual{R:Extensions author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "Writing R extensions", annote = {{ISBN} 3-900051-11-9}, + doi = "10.32614/R.manuals", url = manuals # "R-exts.html" } @@ -682,9 +819,10 @@ @manual{R:Internals author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "R internals", annote = {{ISBN} 3-900051-14-3}, + doi = "10.32614/R.manuals", url = manuals # "R-ints.html" } @@ -692,9 +830,10 @@ @manual{R:Language author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "R language", annote = {{ISBN} 3-900051-13-5}, + doi = "10.32614/R.manuals", url = manuals # "R-lang.html" } @@ -704,7 +843,8 @@ @Manual{R:Main author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, + doi = "10.32614/R.manuals", url = {https://www.R-project.org/} } @@ -727,7 +867,7 @@ @Manual{Samperi:2009:RcppTemplate @article{Sanderson+Curtin:2016, doi = {10.21105/joss.00026}, - url = {http://dx.doi.org/10.21105/joss.00026}, + url = {https://dx.doi.org/10.21105/joss.00026}, year = 2016, month = {{June}}, publisher = {The Open Journal}, @@ -746,7 +886,7 @@ @TechReport{Sanderson:2010:Armadillo Experiments }, institution = {{NICTA}}, year = 2010, - url = "http://arma.sf.net" + url = "https://arma.sourceforge.net" } @Book{Stroustrup:1997:Cpp, @@ -776,6 +916,7 @@ @Article{TAS:Rcpp number = 1, year = 2018, month = {August}, + url = {https://doi.org/10.1080/00031305.2017.1375990}, doi = {10.1080/00031305.2017.1375990} } @@ -811,7 +952,7 @@ @InProceedings{Urbanek:2003:Rserve Statistical Computing, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch and Achim Zeileis}, year = {2003}, - url = {http://www.ci.tuwien.ac.at/Conferences/DSC-2003/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2003/Proceedings/}, note = {{ISSN 1609-395X}} } @@ -836,6 +977,7 @@ @inproceedings{Veldhuizen:1998:Blitz address = {London}, } + @Book{Venables+Ripley:2000:SProgramming, author = {Willian N. Venables and Brian D. Ripley}, title = {S Programming}, @@ -845,6 +987,7 @@ @Book{Venables+Ripley:2000:SProgramming address = {New York} } + @Book{Venables+Ripley:2002:MASS, title = {Modern Applied Statistics with S}, author = {W. N. Venables and B. D. Ripley}, @@ -853,5 +996,32 @@ @Book{Venables+Ripley:2002:MASS address = {New York}, year = 2002, note = {ISBN 0-387-95457-0}, - url = {http://www.stats.ox.ac.uk/pub/MASS4}, + url = {https://www.stats.ox.ac.uk/pub/MASS4/}, +} + +@misc{arxiv:corels, + title = {Learning Certifiably Optimal Rule Lists for + Categorical Data}, + author = {Elaine Angelino and Nicholas Larus-Stone and Daniel + Alabi and Margo Seltzer and Cynthia Rudin}, + year = 2017, + howpublished = {\href{https://www.arxiv.org/abs/1704.01701}{arXiv:1704.01701}}, + archivePrefix ={arXiv}, + primaryClass = {stat.ML} +} + +@Misc{github:corels, + author = {Nicholas Laurus-Stone}, + title = {corels: {Learning Certifiably Optimal Rule Lists}}, + 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 +} + +@Misc{github:rcppcorels, + author = {Dirk Eddelbuettel}, + title = {RcppCorels: R binding for the 'Certifiably Optimal RulE ListS (Corels)' Learner}, + howpublished = {\url{https://github.com/corels/rcppcorels}}, + month = 11, + year = 2019 } diff --git a/inst/examples/Misc/piSugar.cpp b/inst/examples/Misc/piSugar.cpp index 77a26d280..69fa040e1 100644 --- a/inst/examples/Misc/piSugar.cpp +++ b/inst/examples/Misc/piSugar.cpp @@ -5,9 +5,8 @@ using namespace Rcpp; // [[Rcpp::export]] double piSugar(const int N) { - RNGScope scope; // ensure RNG gets set/reset - NumericVector x = runif(N); - NumericVector y = runif(N); - NumericVector d = sqrt(x*x + y*y); - return 4.0 * sum(d < 1.0) / N; + NumericVector x = runif(N); + NumericVector y = runif(N); + NumericVector d = sqrt(x*x + y*y); + return 4.0 * sum(d < 1.0) / N; } diff --git a/inst/examples/RcppGibbs/RcppGibbs.R b/inst/examples/RcppGibbs/RcppGibbs.R index 9f62b339f..6ab088da6 100644 --- a/inst/examples/RcppGibbs/RcppGibbs.R +++ b/inst/examples/RcppGibbs/RcppGibbs.R @@ -100,7 +100,7 @@ gibbscode <- ' int i,j; NumericMatrix mat(N, 2); - RNGScope scope; // Initialize Random number generator + RNGScope scope; // Initialize Random number generator. Not needed when Attributes used. // The rest of the code follows the R version double x=0, y=0; @@ -174,10 +174,10 @@ NumericMatrix RcppGibbs(int N, int thn){ // Setup storage matrix NumericMatrix mat(N, 2); - + // The rest of the code follows the R version double x = 0, y = 0; - + for (int i = 0; i < N; i++) { for (int j = 0; j < thn; j++) { x = R::rgamma(3.0,1.0/(y*y+4)); @@ -186,14 +186,14 @@ NumericMatrix RcppGibbs(int N, int thn){ mat(i,0) = x; mat(i,1) = y; } - + return mat; // Return to R }') ## Use of the sourceCpp() is preferred for users who wish to source external ## files or specify their headers and Rcpp attributes within their code. -## Code here is able to easily be extracted and placed into its own C++ file. +## Code here is able to easily be extracted and placed into its own C++ file. ## Compile and Load sourceCpp(code=" @@ -219,7 +219,7 @@ NumericMatrix GSLGibbs(int N, int thin){ mat(i,1) = y; } gsl_rng_free(r); - + return mat; // Return to R }") @@ -289,5 +289,3 @@ print(res) ## And we are done - - diff --git a/inst/examples/RcppGibbs/RcppGibbs_Updated.R b/inst/examples/RcppGibbs/RcppGibbs_Updated.R new file mode 100644 index 000000000..938b2d1b1 --- /dev/null +++ b/inst/examples/RcppGibbs/RcppGibbs_Updated.R @@ -0,0 +1,189 @@ +## Simple Gibbs Sampler Example +## Adapted from Darren Wilkinson's post at +## http://darrenjw.wordpress.com/2010/04/28/mcmc-programming-in-r-python-java-and-c/ +## +## Sanjog Misra and Dirk Eddelbuettel, June-July 2011 +## Updated by Dirk Eddelbuettel, Mar 2020 + +suppressMessages({ + library(Rcpp) + library(rbenchmark) +}) + + +## Actual joint density -- the code which follow implements +## a Gibbs sampler to draw from the following joint density f(x,y) +fun <- function(x,y) { + x*x * exp(-x*y*y - y*y + 2*y - 4*x) +} + +## Note that the full conditionals are propotional to +## f(x|y) = (x^2)*exp(-x*(4+y*y)) : a Gamma density kernel +## f(y|x) = exp(-0.5*2*(x+1)*(y^2 - 2*y/(x+1)) : Normal Kernel + +## There is a small typo in Darrens code. +## The full conditional for the normal has the wrong variance +## It should be 1/sqrt(2*(x+1)) not 1/sqrt(1+x) +## This we can verify ... +## The actual conditional (say for x=3) can be computed as follows +## First - Construct the Unnormalized Conditional +fy.unnorm <- function(y) fun(3,y) + +## Then - Find the appropriate Normalizing Constant +K <- integrate(fy.unnorm,-Inf,Inf) + +## Finally - Construct Actual Conditional +fy <- function(y) fy.unnorm(y)/K$val + +## Now - The corresponding Normal should be +fy.dnorm <- function(y) { + x <- 3 + dnorm(y,1/(1+x),sqrt(1/(2*(1+x)))) +} + +## and not ... +fy.dnorm.wrong <- function(y) { + x <- 3 + dnorm(y,1/(1+x),sqrt(1/((1+x)))) +} + +if (interactive()) { + ## Graphical check + ## Actual (gray thick line) + curve(fy,-2,2,col='grey',lwd=5) + + ## Correct Normal conditional (blue dotted line) + curve(fy.dnorm,-2,2,col='blue',add=T,lty=3) + + ## Wrong Normal (Red line) + curve(fy.dnorm.wrong,-2,2,col='red',add=T) +} + +## Here is the actual Gibbs Sampler +## This is Darren Wilkinsons R code (with the corrected variance) +## But we are returning only his columns 2 and 3 as the 1:N sequence +## is never used below +Rgibbs <- function(N,thin) { + mat <- matrix(0,ncol=2,nrow=N) + x <- 0 + y <- 0 + for (i in 1:N) { + for (j in 1:thin) { + x <- rgamma(1,3,y*y+4) + y <- rnorm(1,1/(x+1),1/sqrt(2*(x+1))) + } + mat[i,] <- c(x,y) + } + mat +} + +## Now for the Rcpp version -- Notice how easy it is to code up! + +cppFunction("NumericMatrix RcppGibbs(int N, int thn){ + NumericMatrix mat(N, 2); // Setup storage + double x = 0, y = 0; // The rest follows the R version + for (int i = 0; i < N; i++) { + for (int j = 0; j < thn; j++) { + x = R::rgamma(3.0,1.0/(y*y+4)); + y = R::rnorm(1.0/(x+1),1.0/sqrt(2*x+2)); + } + mat(i,0) = x; + mat(i,1) = y; + } + return mat; // Return to R +}") + + +## Use of the sourceCpp() is preferred for users who wish to source external +## files or specify their headers and Rcpp attributes within their code. +## Code here is able to easily be extracted and placed into its own C++ file. + +## Compile and Load +sourceCpp(code=" +#include +#include +#include + +using namespace Rcpp; // just to be explicit + +// [[Rcpp::depends(RcppGSL)]] + +// [[Rcpp::export]] +NumericMatrix GSLGibbs(int N, int thin){ + gsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937); + double x = 0, y = 0; + NumericMatrix mat(N, 2); + for (int i = 0; i < N; i++) { + for (int j = 0; j < thin; j++) { + x = gsl_ran_gamma(r,3.0,1.0/(y*y+4)); + y = 1.0/(x+1)+gsl_ran_gaussian(r,1.0/sqrt(2*x+2)); + } + mat(i,0) = x; + mat(i,1) = y; + } + gsl_rng_free(r); + + return mat; // Return to R +}") + + + +## Now for some tests +## You can try other values if you like +## Note that the total number of interations are N*thin! +Ns <- c(1000,5000,10000,20000) +thins <- c(10,50,100,200) +tim_R <- rep(0,4) +tim_Rgsl <- rep(0,4) +tim_Rcpp <- rep(0,4) + +for (i in seq_along(Ns)) { + tim_R[i] <- system.time(mat <- Rgibbs(Ns[i],thins[i]))[3] + tim_Rgsl[i] <- system.time(gslmat <- GSLGibbs(Ns[i],thins[i]))[3] + tim_Rcpp[i] <- system.time(rcppmat <- RcppGibbs(Ns[i],thins[i]))[3] + cat("Replication #", i, "complete \n") +} + +## Comparison +speedup <- round(tim_R/tim_Rcpp,2); +speedup2 <- round(tim_R/tim_Rgsl,2); +summtab <- round(rbind(tim_R, tim_Rcpp,tim_Rgsl,speedup,speedup2),3) +colnames(summtab) <- c("N=1000","N=5000","N=10000","N=20000") +rownames(summtab) <- c("Elasped Time (R)","Elapsed Time (Rcpp)", "Elapsed Time (Rgsl)", + "SpeedUp Rcpp", "SpeedUp GSL") +print(summtab) + +## Contour Plots -- based on Darren's example +if (interactive() && require(KernSmooth)) { + op <- par(mfrow=c(4,1),mar=c(3,3,3,1)) + x <- seq(0,4,0.01) + y <- seq(-2,4,0.01) + z <- outer(x,y,fun) + contour(x,y,z,main="Contours of actual distribution",xlim=c(0,2), ylim=c(-2,4)) + fit <- bkde2D(as.matrix(mat),c(0.1,0.1)) + contour(drawlabels=T, fit$x1, fit$x2, fit$fhat, xlim=c(0,2), ylim=c(-2,4), + main=paste("Contours of empirical distribution:",round(tim_R[4],2)," seconds")) + fitc <- bkde2D(as.matrix(rcppmat),c(0.1,0.1)) + contour(fitc$x1,fitc$x2,fitc$fhat,xlim=c(0,2), ylim=c(-2,4), + main=paste("Contours of Rcpp based empirical distribution:",round(tim_Rcpp[4],2)," seconds")) + fitg <- bkde2D(as.matrix(gslmat),c(0.1,0.1)) + contour(fitg$x1,fitg$x2,fitg$fhat,xlim=c(0,2), ylim=c(-2,4), + main=paste("Contours of GSL based empirical distribution:",round(tim_Rgsl[4],2)," seconds")) + par(op) +} + + +## also use rbenchmark package +N <- 20000 +thn <- 200 +res <- benchmark(Rgibbs(N, thn), + RcppGibbs(N, thn), + GSLGibbs(N, thn), + columns=c("test", "replications", "elapsed", + "relative", "user.self", "sys.self"), + order="relative", + replications=10) +print(res) + + +## And we are done diff --git a/inst/examples/RcppGibbs/timeRNGs.R b/inst/examples/RcppGibbs/timeRNGs.R index bc444b890..036c2341e 100644 --- a/inst/examples/RcppGibbs/timeRNGs.R +++ b/inst/examples/RcppGibbs/timeRNGs.R @@ -3,111 +3,36 @@ suppressMessages(library(Rcpp)) suppressMessages(library(inline)) suppressMessages(library(rbenchmark)) -## NOTE: This is the old way to compile Rcpp code inline. -## The code here has left as a historical artifact and tribute to the old way. -## Please use the code under the "new" inline compilation section. - -rcppGamma_old <- cxxfunction(signature(xs="numeric"), plugin="Rcpp", body=' - NumericVector x(xs); - int n = x.size(); - - // Initialize Random number generator - RNGScope scope; - - const double y = 1.234; - for (int i=0; i #include #include +#include #include #include @@ -56,6 +57,8 @@ #include #include +#include + #if !defined(RCPP_FORCE_OLD_DATE_DATETIME_VECTORS) #define RCPP_NEW_DATE_DATETIME_VECTORS 1 #endif @@ -63,8 +66,10 @@ #include +#ifndef RCPP_NO_MODULES #include #include +#endif #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 580eb5a26..6e2062715 100644 --- a/inst/include/Rcpp/DataFrame.h +++ b/inst/include/Rcpp/DataFrame.h @@ -2,7 +2,7 @@ // // DataFrame.h: Rcpp R/C++ interface class library -- data frames // -// Copyright (C) 2010 - 2015 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -61,31 +61,43 @@ 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 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 { + Shield rn{Rf_getAttrib(Parent::get__(), R_RowNamesSymbol)}; + return Rf_xlength(rn); + } + + template + void push_back( const T& object){ + Parent::push_back(object); + set_type_after_push(); + } + + template + void push_back( const T& object, const std::string& name ){ + Parent::push_back(object, name); + set_type_after_push(); + } + + template + void push_front( const T& object){ + Parent::push_front(object); + set_type_after_push(); + } + + template + void push_front( const T& object, const std::string& name){ + Parent::push_front(object, name); + set_type_after_push(); } // 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(); } @@ -93,19 +105,46 @@ namespace Rcpp{ static DataFrame_Impl create(){ return DataFrame_Impl() ; } - - #include + template + static DataFrame_Impl create(const T&... args) { + return DataFrame_Impl::from_list(Parent::create(args...)); + } private: void set__(SEXP x){ if( ::Rf_inherits( x, "data.frame" )){ Parent::set__( x ) ; } else{ - SEXP y = internal::convert_using_rfunction( x, "as.data.frame" ) ; + Shield y(internal::convert_using_rfunction( x, "as.data.frame" )) ; Parent::set__( y ) ; } } + void set_type_after_push(){ + R_xlen_t max_rows = 0; + bool invalid_column_size = false; + List::iterator it; + // Get the maximum number of rows + for (it = Parent::begin(); it != Parent::end(); ++it) { + if (Rf_xlength(*it) > max_rows) { + max_rows = Rf_xlength(*it); + } + } + if (max_rows > 0) { + for (it = Parent::begin(); it != Parent::end(); ++it) { + if (Rf_xlength(*it) == 0 || ( Rf_xlength(*it) > 1 && max_rows % Rf_xlength(*it) != 0 )) { + // We have a column that is not an integer fraction of the largest + invalid_column_size = true; + } + } + } + if (invalid_column_size) { + warning("Column sizes are not equal in DataFrame::push_back, object degrading to List\n"); + } else { + set__(Parent::get__()); + } + } + static DataFrame_Impl from_list( Parent obj ){ bool use_default_strings_as_factors = true ; bool strings_as_factors = true ; @@ -130,7 +169,7 @@ namespace Rcpp{ obj.erase(strings_as_factors_index) ; names.erase(strings_as_factors_index) ; obj.attr( "names") = names ; - Shield call( Rf_lang3(as_df_symb, obj, wrap( strings_as_factors ) ) ) ; + Shield call( Rf_lang3(as_df_symb, obj, Rf_ScalarLogical(strings_as_factors) ) ) ; SET_TAG( CDDR(call), strings_as_factors_symb ) ; Shield res(Rcpp_fast_eval(call, R_GlobalEnv)); DataFrame_Impl out( res ) ; diff --git a/inst/include/Rcpp/DottedPair.h b/inst/include/Rcpp/DottedPair.h index e056e2d85..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,8 +35,10 @@ RCPP_API_CLASS(DottedPair_Impl), DottedPair_Impl(SEXP x) { Storage::set__(x) ; } - - #include + 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 f1bd572ee..bc89a702f 100644 --- a/inst/include/Rcpp/Environment.h +++ b/inst/include/Rcpp/Environment.h @@ -1,9 +1,8 @@ -// -*- 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 Dirk Eddelbuettel, Romain Francois and Kevin Ushey +// Copyright (C) 2009 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2014 - 2025 Dirk Eddelbuettel, Romain Francois and Kevin Ushey // // This file is part of Rcpp. // @@ -33,8 +32,8 @@ namespace Rcpp{ if( Rf_isEnvironment(x) ) return x ; SEXP asEnvironmentSym = Rf_install("as.environment"); try { - Shield res(Rcpp_fast_eval(Rf_lang2(asEnvironmentSym, x), R_GlobalEnv)); - return res ; + Shield call(Rf_lang2(asEnvironmentSym, x)); + return Rcpp_fast_eval(call, R_GlobalEnv); } catch( const eval_error& ex) { const char* fmt = "Cannot convert object to an environment: " "[type=%s; target=ENVSXP]."; @@ -84,12 +83,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 ; } @@ -103,13 +97,16 @@ namespace Rcpp{ SEXP get(const std::string& name) const { SEXP env = Storage::get__() ; SEXP nameSym = Rf_install(name.c_str()); +#if R_VERSION < R_Version(4,5,0) SEXP res = Rf_findVarInFrame( env, nameSym ) ; - +#else + SEXP res = R_getVarEx(nameSym, env, FALSE, R_UnboundValue); +#endif 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 ) ; + res = internal::Rcpp_eval_impl( res, env ) ; // #nocov } return res ; } @@ -123,7 +120,11 @@ 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 ) ; +#else + SEXP res = R_getVarEx(name, env, FALSE, R_UnboundValue); +#endif if( res == R_UnboundValue ) return R_NilValue ; @@ -145,7 +146,11 @@ namespace Rcpp{ SEXP find( const std::string& name) const{ SEXP env = Storage::get__() ; SEXP nameSym = Rf_install(name.c_str()); +#if R_VERSION < R_Version(4,5,0) SEXP res = Rf_findVar( nameSym, env ) ; +#else + SEXP res = R_getVarEx(nameSym, env, TRUE, R_UnboundValue); +#endif if( res == R_UnboundValue ) throw binding_not_found(name) ; @@ -164,8 +169,11 @@ 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 ) ; - +#else + SEXP res = R_getVarEx(name, env, TRUE, R_UnboundValue); +#endif if( res == R_UnboundValue ) { // Pass on the const char* to the RCPP_EXCEPTION_CLASS's // const std::string& requirement @@ -189,7 +197,11 @@ 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 ) ; +#else + SEXP res = R_getVarEx(nameSym, Storage::get__(), FALSE, R_UnboundValue); +#endif return res != R_UnboundValue ; } @@ -246,9 +258,8 @@ namespace Rcpp{ we have to go back to R to do this operation */ SEXP internalSym = Rf_install( ".Internal" ); SEXP removeSym = Rf_install( "remove" ); - Shield call( Rf_lang2(internalSym, - Rf_lang4(removeSym, Rf_mkString(name.c_str()), Storage::get__(), Rf_ScalarLogical( FALSE )) - ) ); + Shield str(Rf_mkString(name.c_str())); + Shield call(Rf_lang2(internalSym, Rf_lang4(removeSym, str, Storage::get__(), Rf_ScalarLogical(FALSE)))); Rcpp_fast_eval( call, R_GlobalEnv ) ; } } else{ @@ -319,14 +330,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 */ @@ -374,7 +377,8 @@ namespace Rcpp{ try{ SEXP getNamespaceSym = Rf_install("getNamespace"); Shield package_str( Rf_mkString(package.c_str()) ); - env = Rcpp_fast_eval(Rf_lang2(getNamespaceSym, package_str), R_GlobalEnv); + Shield call( Rf_lang2(getNamespaceSym, package_str) ); + env = Rcpp_fast_eval(call, R_GlobalEnv); } catch( ... ){ throw no_such_namespace( package ) ; } @@ -393,10 +397,10 @@ namespace Rcpp{ */ Environment_Impl new_child(bool hashed) const { SEXP newEnvSym = Rf_install("new.env"); - return Environment_Impl(Rcpp_fast_eval(Rf_lang3(newEnvSym, Rf_ScalarLogical(hashed), Storage::get__()), R_GlobalEnv)); + Shield call(Rf_lang3(newEnvSym, Rf_ScalarLogical(hashed), Storage::get__())); + return Environment_Impl(Rcpp_fast_eval(call, R_GlobalEnv)); } - void update(SEXP){} }; diff --git a/inst/include/Rcpp/Function.h b/inst/include/Rcpp/Function.h index d038a2176..783318b39 100644 --- a/inst/include/Rcpp/Function.h +++ b/inst/include/Rcpp/Function.h @@ -1,8 +1,7 @@ -// -*- 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 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -43,12 +42,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,7 +69,11 @@ namespace Rcpp{ } Function_Impl(const std::string& name, const std::string& ns) { +#if R_VERSION < R_Version(4,5,0) Shield env(Rf_findVarInFrame(R_NamespaceRegistry, Rf_install(ns.c_str()))); +#else + Shield env(R_getVarEx(Rf_install(ns.c_str()), R_NamespaceRegistry, FALSE, R_UnboundValue)); +#endif if (env == R_UnboundValue) { stop("there is no namespace called \"%s\"", ns); } @@ -82,7 +85,10 @@ namespace Rcpp{ return Rcpp_fast_eval(call, R_GlobalEnv); } - #include + template + SEXP operator()(const T&... args) const { + return invoke(pairlist(args...), R_GlobalEnv); + } /** * Returns the environment of this function @@ -92,7 +98,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 } /** @@ -111,6 +121,14 @@ namespace Rcpp{ Shield x( Rf_findFun( nameSym, env ) ) ; Storage::set__(x) ; } + + SEXP invoke(SEXP args_, SEXP env) const { + Shield args(args_); + Shield call(Rcpp_lcons(Storage::get__(), args)); + SEXP out = Rcpp_fast_eval(call, env); + return out; + } + }; typedef Function_Impl Function ; diff --git a/inst/include/Rcpp/InternalFunction.h b/inst/include/Rcpp/InternalFunction.h index 5a5722beb..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( @@ -47,9 +44,11 @@ namespace Rcpp{ ) ); } -#endif + template + InternalFunction_Impl(RESULT_TYPE (*fun)(T...)) { + set(XPtr >(new CppFunctionN(fun), true)); + } - #include void update(SEXP){} private: diff --git a/inst/include/Rcpp/InternalFunctionWithStdFunction.h b/inst/include/Rcpp/InternalFunctionWithStdFunction.h index 966da22bf..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,14 +22,13 @@ #ifndef Rcpp_InternalFunctionWithStdFunction_h #define Rcpp_InternalFunctionWithStdFunction_h +#include #include namespace Rcpp { namespace InternalFunctionWithStdFunction { - #include - template class CppFunctionBaseFromStdFunction : public CppFunctionBase { public: @@ -39,8 +37,7 @@ namespace Rcpp { SEXP operator()(SEXP* args) { BEGIN_RCPP - auto result = call(fun, args); - return Rcpp::module_wrap(result); + return call(fun, args); END_RCPP } @@ -48,22 +45,6 @@ namespace Rcpp { const std::function fun; }; - template - class CppFunctionBaseFromStdFunction : public CppFunctionBase { - public: - CppFunctionBaseFromStdFunction(const std::function &fun) : fun(fun) {} - virtual ~CppFunctionBaseFromStdFunction() {} - - SEXP operator()(SEXP* args) { - BEGIN_RCPP - call(fun, args); - END_RCPP - } - - private: - const std::function fun; - }; - } // namespace InternalFunctionWithStdFunction } // namespace Rcpp diff --git a/inst/include/Rcpp/Language.h b/inst/include/Rcpp/Language.h index 202fe8b21..d893df67a 100644 --- a/inst/include/Rcpp/Language.h +++ b/inst/include/Rcpp/Language.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // Language.h: Rcpp R/C++ interface class library -- language objects (calls) // -// 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,8 +34,8 @@ namespace Rcpp{ { public: - typedef typename DottedPairProxyPolicy::DottedPairProxy Proxy ; - typedef typename DottedPairProxyPolicy::const_DottedPairProxy const_Proxy ; + typedef typename DottedPairProxyPolicy::DottedPairProxy Proxy; + typedef typename DottedPairProxyPolicy::const_DottedPairProxy const_Proxy; RCPP_GENERATE_CTOR_ASSIGN(Language_Impl) @@ -49,7 +48,7 @@ namespace Rcpp{ * to a call using as.call */ Language_Impl(SEXP x){ - Storage::set__( r_cast(x) ) ; + Storage::set__( r_cast(x) ); } /** @@ -62,7 +61,7 @@ namespace Rcpp{ * > call( "rnorm" ) */ explicit Language_Impl( const std::string& symbol ){ - Storage::set__( Rf_lang1( Rf_install(symbol.c_str()) ) ) ; + Storage::set__( Rf_lang1( Rf_install(symbol.c_str()) ) ); } /** @@ -74,7 +73,7 @@ namespace Rcpp{ * > call( "rnorm" ) */ explicit Language_Impl( const Symbol& symbol ){ - Storage::set__( Rf_lang1( symbol ) ) ; + Storage::set__( Rf_lang1( symbol ) ); } /** @@ -83,7 +82,7 @@ namespace Rcpp{ * @param function function to call */ explicit Language_Impl( const Function& function) { - Storage::set__( Rf_lang1( function ) ) ; + Storage::set__( Rf_lang1( function ) ); } /** @@ -103,21 +102,29 @@ namespace Rcpp{ * 0.0 is wrapped as a numeric vector using wrap( const& double ) * ... */ - #include + 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__(langlist(function, t...)); + } /** * sets the symbol of the call */ void setSymbol( const std::string& symbol){ - setSymbol( Symbol( symbol ) ) ; + setSymbol( Symbol( symbol ) ); } /** * sets the symbol of the call */ void setSymbol( const Symbol& symbol ){ - SEXP x = Storage::get__() ; - SETCAR( x, symbol ) ; + SEXP x = Storage::get__(); + SETCAR( x, symbol ); SET_TAG(x, R_NilValue); } @@ -125,7 +132,7 @@ namespace Rcpp{ * sets the function */ void setFunction( const Function& function){ - SEXP x = Storage::get__() ; + SEXP x = Storage::get__(); SETCAR( x, function ); SET_TAG(x, R_NilValue); /* probably not necessary */ } @@ -134,83 +141,85 @@ namespace Rcpp{ * eval this call in the global environment */ SEXP eval() const { - return Rcpp_fast_eval( Storage::get__(), R_GlobalEnv ) ; + return Rcpp_fast_eval( Storage::get__(), R_GlobalEnv ); } /** * eval this call in the requested environment */ SEXP eval(SEXP env) const { - return Rcpp_fast_eval( Storage::get__(), env ) ; + return Rcpp_fast_eval( Storage::get__(), env ); } SEXP fast_eval() const { - return internal::Rcpp_eval_impl( Storage::get__(), R_GlobalEnv) ; + return internal::Rcpp_eval_impl( Storage::get__(), R_GlobalEnv); } SEXP fast_eval(SEXP env ) const { - return internal::Rcpp_eval_impl( Storage::get__(), env) ; + return internal::Rcpp_eval_impl( Storage::get__(), env); } - void update( SEXP x){ - SET_TYPEOF( x, LANGSXP ) ; - SET_TAG( x, R_NilValue ) ; + void update(SEXP x) { + if (TYPEOF(x) != LANGSXP) { + Storage::set__(r_cast(x)); + } + SET_TAG( x, R_NilValue ); } }; - typedef Language_Impl Language ; + typedef Language_Impl Language; template class fixed_call { public: - typedef RESULT_TYPE result_type ; + typedef RESULT_TYPE result_type; fixed_call( Language call_ ) : call(call_){} fixed_call( Function fun ) : call(fun){} RESULT_TYPE operator()(){ - return as( call.eval() ) ; + return as( call.eval() ); } private: - Language call ; - } ; + Language call; + }; template - class unary_call : public std::unary_function { + class unary_call : public std::function { public: unary_call( Language call_ ) : call(call_), proxy(call_,1) {} unary_call( Language call_, R_xlen_t index ) : call(call_), proxy(call_,index){} unary_call( Function fun ) : call( fun, R_NilValue), proxy(call,1) {} RESULT_TYPE operator()( const T& object ){ - proxy = object ; - return as( call.eval() ) ; + proxy = object; + return as( call.eval() ); } private: - Language call ; - Language::Proxy proxy ; - } ; + Language call; + Language::Proxy proxy; + }; template - class binary_call : public std::binary_function { + class binary_call : public std::function { 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){} binary_call( Function fun) : call(fun, R_NilValue, R_NilValue), proxy1(call,1), proxy2(call,2){} RESULT_TYPE operator()( const T1& o1, const T2& o2 ){ - proxy1 = o1 ; - proxy2 = o2 ; - return as( call.eval() ) ; + proxy1 = o1; + proxy2 = o2; + return as( call.eval() ); } private: - Language call ; - Language::Proxy proxy1 ; - Language::Proxy proxy2 ; - } ; + Language call; + Language::Proxy proxy1; + Language::Proxy proxy2; + }; } // namespace Rcpp diff --git a/inst/include/Rcpp/Light b/inst/include/Rcpp/Light new file mode 100644 index 000000000..dffc88d97 --- /dev/null +++ b/inst/include/Rcpp/Light @@ -0,0 +1,25 @@ +// Rcpp/Light: R/C++ interface class library -- without Rcpp Modules +// +// Copyright (C) 2008 - 2021 Dirk Eddelbuettel +// Copyright (C) 2009 - 2021 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 . + +// no Modules +#define RCPP_NO_MODULES + +// include Rcpp as usual +#include diff --git a/inst/include/Rcpp/Lighter b/inst/include/Rcpp/Lighter new file mode 100644 index 000000000..78b56e5b5 --- /dev/null +++ b/inst/include/Rcpp/Lighter @@ -0,0 +1,25 @@ +// Rcpp/Lighter: R/C++ interface class library -- without Rcpp Modules + RTTI +// +// Copyright (C) 2008 - 2021 Dirk Eddelbuettel +// Copyright (C) 2009 - 2021 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 . + +// no RTTI (actually implies no Modules) -- solid gain +#define RCPP_NO_RTTI + +// include Rcpp/Light which includes Rcpp +#include diff --git a/inst/include/Rcpp/Lightest b/inst/include/Rcpp/Lightest new file mode 100644 index 000000000..cd501c796 --- /dev/null +++ b/inst/include/Rcpp/Lightest @@ -0,0 +1,26 @@ +// Rcpp/Lightest: R/C++ interface class library -- without Rcpp Modules, RTTI, Sugar +// +// Copyright (C) 2008 - 2021 Dirk Eddelbuettel +// Copyright (C) 2009 - 2021 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 . +// New (draft) header with optional components off + +// no Sugar (but unclear how much it helps) +#define RCPP_NO_SUGAR + +// include Rcpp/Lighter +#include diff --git a/inst/include/Rcpp/Module.h b/inst/include/Rcpp/Module.h index 88d3a0765..7556e9f3c 100644 --- a/inst/include/Rcpp/Module.h +++ b/inst/include/Rcpp/Module.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // 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. // @@ -23,6 +22,7 @@ #define Rcpp_Module_h #include +#include namespace Rcpp{ @@ -85,10 +85,53 @@ namespace Rcpp{ #include #include -#include - // templates CppFunction0, ..., CppFunction65 -#include +namespace Rcpp { + template + inline void signature(std::string& s, const char* name) { + s.clear(); + s += get_return_type() + " " + name + "("; + int n = sizeof...(T); + int i = 0; + // Using initializer list as c++11 implementation of a fold expression + (void)std::initializer_list{ + (s += get_return_type(), s += (++i == n ? "" : ", "), 0)... }; + s += ")"; + } + + template + class CppFunctionN : public CppFunction { + public: + CppFunctionN(RESULT_TYPE (*fun)(T...), const char* docstring = 0) : CppFunction(docstring), ptr_fun(fun) {} + + SEXP operator()(SEXP* args) { + BEGIN_RCPP + return call(ptr_fun, args); + END_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; } + + private: + RESULT_TYPE (*ptr_fun)(T...); + }; + + template + class CppFunction_WithFormalsN : public CppFunctionN { + public: + CppFunction_WithFormalsN(RESULT_TYPE (*fun)(T...), Rcpp::List formals_, const char* docstring = 0) : + CppFunctionN(fun, docstring), formals(formals_) {} + + SEXP get_formals() { return formals; } + + private: + Rcpp::List formals; + }; +} + #include #include @@ -130,11 +173,78 @@ namespace Rcpp{ ParentMethod* parent_method_pointer ; } ; -#include -#include -#include + template + inline void ctor_signature(std::string& s, const std::string& classname) { + s.assign(classname); + s += "("; + int n = sizeof...(T); + int i = 0; + // Using initializer list as c++11 implementation of a fold expression + (void)std::initializer_list{ + (s += get_return_type(), s += (++i == n ? "" : ", "), 0)... }; + s += ")"; + } + 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 ; + } ; -#include + template + class Constructor: public Constructor_Base { + public: + virtual Class* get_new( SEXP* args, int nargs ){ + return get_new_impl(args, nargs, traits::make_index_sequence()); + } + virtual int nargs(){ return sizeof...(T) ; } + virtual void signature(std::string& s, const std::string& class_name ){ + ctor_signature(s, class_name) ; + } + + private: + template + Class* get_new_impl(SEXP* args, int nargs, traits::index_sequence) { + return new Class( as(args[Is])... ) ; + } + }; + + 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 : public Factory_Base { + public: + Factory( Class* (*fun)(T...) ) : ptr_fun(fun){} + virtual Class* get_new( SEXP* args, int nargs ){ + return get_new( args, traits::make_index_sequence() ) ; + } + virtual int nargs(){ return sizeof...(T) ; } + virtual void signature(std::string& s, const std::string& class_name ){ + ctor_signature(s, class_name) ; + } + private: + template + Class* get_new( SEXP* args, traits::index_sequence ){ + return ptr_fun( bare_as(args[I])... ) ; + } + Class* (*ptr_fun)(T...) ; + } ; + + inline bool yes( SEXP* /*args*/, int /* nargs */ ){ + return true ; + } + + template + bool yes_arity( SEXP* /* args */ , int nargs){ + return nargs == n ; + } typedef bool (*ValidConstructor)(SEXP*,int) ; typedef bool (*ValidMethod)(SEXP*,int) ; @@ -229,7 +339,7 @@ namespace Rcpp{ typedef std::vector vec_signed_method ; S4_CppOverloadedMethods( vec_signed_method* m, const XP_Class& class_xp, const char* name, std::string& buffer ) : Reference( "C++OverloadedMethods" ){ - int n = m->size() ; + int n = static_cast(m->size()) ; Rcpp::LogicalVector voidness(n), constness(n) ; Rcpp::CharacterVector docstrings(n), signatures(n) ; Rcpp::IntegerVector nargs(n) ; @@ -259,8 +369,68 @@ namespace Rcpp{ } ; -#include -#include + + template + class CppMethodImplN : public CppMethod { + public: + typedef typename std::conditional::type Method; + typedef CppMethod method_class; + typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; + + CppMethodImplN(Method m) : method_class(), met(m) {} + SEXP operator()(Class* object, SEXP* args) { + // Can't pass pointer to member function directly to `call()`, so wrap it in a lambda + auto f = [&object, this](T... cpp_args) -> CLEANED_RESULT_TYPE { + return (object->*met)(cpp_args...); + }; + return call(f, args); + } + inline int nargs() { return sizeof...(T); } + 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: + Method met; + }; + + template + using CppMethodN = CppMethodImplN; + + template + using const_CppMethodN = CppMethodImplN; + + template + class Pointer_CppMethodImplN : public CppMethod { + public: + typedef typename std::conditional::type Method; + typedef CppMethod method_class; + typedef typename Rcpp::traits::remove_const_and_reference::type CLEANED_RESULT_TYPE; + + Pointer_CppMethodImplN(Method m) : method_class(), met(m) {} + SEXP operator()(Class* object, SEXP* args) { + // Need to have `object` as the first argument to the function, so wrap it in a lambda + auto f = [&object, this](T... cpp_args) -> CLEANED_RESULT_TYPE { + return met(object, cpp_args...); + }; + return call(f, args); + } + inline int nargs() { return sizeof...(T); } + 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: + Method met; + }; + + template + using Pointer_CppMethodN = Pointer_CppMethodImplN; + + template + using Const_Pointer_CppMethodN = Pointer_CppMethodImplN; + + template class CppProperty { @@ -368,8 +538,25 @@ namespace Rcpp{ } ; } -// function factories -#include + +namespace Rcpp { + template + void function(const char* name_, RESULT_TYPE (*fun)(T... t), const char* docstring = 0) { + Rcpp::Module* scope = ::getCurrentScope(); + if (scope) { + scope->Add(name_, new CppFunctionN(fun, docstring)); + } + } + + template + void function(const char* name_, RESULT_TYPE (*fun)(T... t), Rcpp::List formals, const char* docstring = 0) { + Rcpp::Module* scope = ::getCurrentScope(); + if (scope) { + scope->Add(name_, new CppFunction_WithFormalsN(fun, formals, docstring)); + } + } +} + namespace Rcpp { @@ -384,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 ) ; @@ -457,4 +644,3 @@ static VARIABLE_IS_NOT_USED SEXP moduleSym = NULL; Rcpp_fast_eval( __load_module_call__, R_GlobalEnv ); #endif - diff --git a/inst/include/Rcpp/Pairlist.h b/inst/include/Rcpp/Pairlist.h index 043615efb..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,11 +42,15 @@ namespace Rcpp{ Pairlist_Impl(SEXP x){ Storage::set__(r_cast(x)) ; } + template + Pairlist_Impl(const T&... args ){ + Storage::set__(pairlist(args... )) ; + } - #include - - void update(SEXP x){ - SET_TYPEOF( x, LISTSXP ) ; + void update(SEXP x) { + if (TYPEOF(x) != LISTSXP) { + Storage::set__(r_cast(x)); + } } } ; diff --git a/inst/include/Rcpp/Rcpp b/inst/include/Rcpp/Rcpp new file mode 100644 index 000000000..eef8b8894 --- /dev/null +++ b/inst/include/Rcpp/Rcpp @@ -0,0 +1,21 @@ +// Rcpp/Rcpp: R/C++ interface class library +// +// Copyright (C) 2008 - 2021 Dirk Eddelbuettel +// Copyright (C) 2009 - 2021 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 . + +#include diff --git a/inst/include/Rcpp/Reference.h b/inst/include/Rcpp/Reference.h index 55f99e7f2..4bd08276f 100644 --- a/inst/include/Rcpp/Reference.h +++ b/inst/include/Rcpp/Reference.h @@ -2,7 +2,7 @@ // // Reference.h: Rcpp R/C++ interface class library -- Reference class objects // -// Copyright (C) 2010 - 2015 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2019 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -58,7 +58,8 @@ namespace Rcpp{ */ Reference_Impl( const std::string& klass ) { SEXP newSym = Rf_install("new"); - Shield call( Rf_lang2( newSym, Rf_mkString( klass.c_str() ) ) ); + Shield str(Rf_mkString(klass.c_str())); + Shield call(Rf_lang2(newSym, str)); Storage::set__( Rcpp_fast_eval( call , Rcpp::internal::get_Rcpp_namespace()) ); } 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 dd771d0ef..2103e5b28 100644 --- a/inst/include/Rcpp/String.h +++ b/inst/include/Rcpp/String.h @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // String.h: Rcpp R/C++ interface class library -- single string // -// Copyright (C) 2012 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2020 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 - 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -29,10 +29,10 @@ #if RCPP_STRING_DEBUG_LEVEL > 0 #define RCPP_STRING_DEBUG_FORMAT "%40s:%4d " - #define RCPP_STRING_DEBUG(MSG) Rprintf(RCPP_STRING_DEBUG_FORMAT "%s\n" , short_file_name(__FILE__), __LINE__, MSG); - #define RCPP_STRING_DEBUG_1(fmt, MSG) Rprintf(RCPP_STRING_DEBUG_FORMAT fmt "\n" , short_file_name(__FILE__), __LINE__, MSG); - #define RCPP_STRING_DEBUG_2(fmt, M1, M2) Rprintf(RCPP_STRING_DEBUG_FORMAT fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2); - #define RCPP_STRING_DEBUG_3(fmt, M1, M2, M3) Rprintf(RCPP_STRING_DEBUG_FORMAT fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2, M3); + #define RCPP_STRING_DEBUG(MSG) Rprintf(RCPP_STRING_DEBUG_FORMAT "%s\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG); + #define RCPP_STRING_DEBUG_1(fmt, MSG) Rprintf(RCPP_STRING_DEBUG_FORMAT fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG); + #define RCPP_STRING_DEBUG_2(fmt, M1, M2) Rprintf(RCPP_STRING_DEBUG_FORMAT fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2); + #define RCPP_STRING_DEBUG_3(fmt, M1, M2, M3) Rprintf(RCPP_STRING_DEBUG_FORMAT fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3); #else #define RCPP_STRING_DEBUG(MSG) #define RCPP_STRING_DEBUG_1(fmt, MSG) @@ -52,19 +52,22 @@ namespace Rcpp { typedef internal::const_string_proxy const_StringProxy; /** default constructor */ - String(): data(Rf_mkCharCE("", CE_UTF8)), buffer(), valid(true), buffer_ready(true), enc(CE_UTF8) { - Rcpp_PreserveObject(data); + String(): data(Rf_mkCharCE("", CE_UTF8)), token(R_NilValue), buffer(), valid(true), buffer_ready(true), enc(CE_UTF8) { + token = Rcpp_PreciousPreserve(data); RCPP_STRING_DEBUG("String()"); } /** copy constructor */ - String(const String& other) : data(other.get_sexp()), valid(true), buffer_ready(false), enc(Rf_getCharCE(other.get_sexp())) { - Rcpp_PreserveObject(data); + String(const String& s) : data(R_NilValue), token(R_NilValue), buffer(s.buffer), valid(s.valid), buffer_ready(s.buffer_ready), enc(s.enc) { + if (!buffer_ready) { + data = s.get_sexp(); + token = Rcpp_PreciousPreserve(data); + } RCPP_STRING_DEBUG("String(const String&)"); } /** construct a string from a single CHARSXP SEXP */ - String(SEXP charsxp) : data(R_NilValue) { + String(SEXP charsxp) : data(R_NilValue), token(R_NilValue) { if (TYPEOF(charsxp) == STRSXP) { data = STRING_ELT(charsxp, 0); } else if (TYPEOF(charsxp) == CHARSXP) { @@ -82,84 +85,223 @@ namespace Rcpp { valid = true; buffer_ready = false; enc = Rf_getCharCE(data); - Rcpp_PreserveObject(data); + token = Rcpp_PreciousPreserve(data); RCPP_STRING_DEBUG("String(SEXP)"); } /** from string proxy */ - String(const StringProxy& proxy): data(proxy.get()), valid(true), buffer_ready(false), enc(Rf_getCharCE(proxy.get())) { - Rcpp_PreserveObject(data); + String(const StringProxy& proxy): data(proxy.get()), token(R_NilValue), valid(true), buffer_ready(false), enc(Rf_getCharCE(proxy.get())) { + token = Rcpp_PreciousPreserve(data); RCPP_STRING_DEBUG("String(const StringProxy&)"); } - String(const StringProxy& proxy, cetype_t enc): data(proxy.get()), valid(true), buffer_ready(false) { - Rcpp_PreserveObject(data); + String(const StringProxy& proxy, cetype_t enc): data(proxy.get()), token(R_NilValue), valid(true), buffer_ready(false) { + token = Rcpp_PreciousPreserve(data); set_encoding(enc); RCPP_STRING_DEBUG("String(const StringProxy&, cetype_t)"); } /** from string proxy */ - String(const const_StringProxy& proxy): data(proxy.get()), valid(true), buffer_ready(false), enc(Rf_getCharCE(proxy.get())) { - Rcpp_PreserveObject(data); + String(const const_StringProxy& proxy): data(proxy.get()), token(R_NilValue), valid(true), buffer_ready(false), enc(Rf_getCharCE(proxy.get())) { + token = Rcpp_PreciousPreserve(data); RCPP_STRING_DEBUG("String(const const_StringProxy&)"); } - String(const const_StringProxy& proxy, cetype_t enc): data(proxy.get()), valid(true), buffer_ready(false) { - Rcpp_PreserveObject(data); + String(const const_StringProxy& proxy, cetype_t enc): data(proxy.get()), token(R_NilValue), valid(true), buffer_ready(false) { + token = Rcpp_PreciousPreserve(data); set_encoding(enc); RCPP_STRING_DEBUG("String(const const_StringProxy&, cetype_t)"); } /** from a std::string */ - String(const std::string& s, cetype_t enc = CE_UTF8) : buffer(s), valid(false), buffer_ready(true), enc(enc) { - data = R_NilValue; + 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)"); } - String(const std::wstring& s, cetype_t enc = CE_UTF8) : data(internal::make_charsexp(s)), valid(true), buffer_ready(false), enc(enc) { - Rcpp_PreserveObject(data); + /** 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. + s.data = R_NilValue; + s.token = R_NilValue; + s.buffer = std::string(); + s.valid = false; + s.buffer_ready = true; + s.enc = CE_UTF8; + RCPP_STRING_DEBUG("String(String&&)"); + } + + /** move a std::string */ + 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)"); + } + + 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)"); } /** from a const char* */ String(const char* s, cetype_t enc = CE_UTF8) : buffer(s), valid(false), buffer_ready(true), enc(enc) { data = R_NilValue; + token = R_NilValue; RCPP_STRING_DEBUG("String(const char*, cetype_t)"); } - String(const wchar_t* s, cetype_t enc = CE_UTF8) : data(internal::make_charsexp(s)), valid(true), buffer_ready(false), enc(enc) { - Rcpp_PreserveObject(data); + String(const wchar_t* 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 wchar_t* s, cetype_t)"); } /** constructors from R primitives */ - String(int x) : data(internal::r_coerce(x)), valid(true), buffer_ready(false), enc(CE_UTF8) {Rcpp_PreserveObject(data);} - String(double x) : data(internal::r_coerce(x)), valid(true), buffer_ready(false), enc(CE_UTF8) {Rcpp_PreserveObject(data);} - String(bool x) : data(internal::r_coerce(x)), valid(true) , buffer_ready(false), enc(CE_UTF8) {Rcpp_PreserveObject(data);} - String(Rcomplex x) : data(internal::r_coerce(x)), valid(true), buffer_ready(false), enc(CE_UTF8) {Rcpp_PreserveObject(data);} - String(Rbyte x) : data(internal::r_coerce(x)), valid(true), buffer_ready(false), enc(CE_UTF8) {Rcpp_PreserveObject(data);} + String(int x) : data(internal::r_coerce(x)), token(R_NilValue), valid(true), buffer_ready(false), enc(CE_UTF8) { + token = Rcpp_PreciousPreserve(data); + } + String(double x) : data(internal::r_coerce(x)), token(R_NilValue), valid(true), buffer_ready(false), enc(CE_UTF8) { + token = Rcpp_PreciousPreserve(data); + } + String(bool x) : data(internal::r_coerce(x)), token(R_NilValue), valid(true) , buffer_ready(false), enc(CE_UTF8) { + token = Rcpp_PreciousPreserve(data); + } + String(Rcomplex x) : data(internal::r_coerce(x)), token(R_NilValue), valid(true), buffer_ready(false), enc(CE_UTF8) { + token = Rcpp_PreciousPreserve(data); + } + String(Rbyte x) : data(internal::r_coerce(x)), token(R_NilValue), valid(true), buffer_ready(false), enc(CE_UTF8) { + token = Rcpp_PreciousPreserve(data); + } ~String() { - Rcpp_ReleaseObject(data); + Rcpp_PreciousRelease(token); data = R_NilValue; + token = R_NilValue; } - inline String& operator=(int x ) { data = Rcpp_ReplaceObject(data, internal::r_coerce(x)); valid = true; buffer_ready = false; return *this; } - inline String& operator=(double x ) { data = Rcpp_ReplaceObject(data, internal::r_coerce(x)); valid = true; buffer_ready = false; return *this; } - inline String& operator=(Rbyte x ) { data = Rcpp_ReplaceObject(data, internal::r_coerce(x)); valid = true; buffer_ready = false; return *this; } - inline String& operator=(bool x ) { data = Rcpp_ReplaceObject(data, internal::r_coerce(x)); valid = true; buffer_ready = false; return *this; } - inline String& operator=(Rcomplex x) { data = Rcpp_ReplaceObject(data, internal::r_coerce(x)); valid = true; buffer_ready = false; return *this; } - inline String& operator=(SEXP x) { data = Rcpp_ReplaceObject(data, x); valid = true; buffer_ready = false; return *this; } - inline String& operator=(const StringProxy& proxy) { data = Rcpp_ReplaceObject(data, proxy.get()); valid = true; buffer_ready=false; return *this; } - inline String& operator=(const String& other) { data = Rcpp_ReplaceObject(data, other.get_sexp()); valid = true; buffer_ready = false; return *this; } - inline String& operator=(const std::string& s) { buffer = s; valid = false; buffer_ready = true; return *this; } - inline String& operator=(const char* s) { buffer = s; valid = false; buffer_ready = true; return *this; } + inline String& operator=(int x) { + data = internal::r_coerce(x); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } + inline String& operator=(double x) { + data = internal::r_coerce(x); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } + inline String& operator=(Rbyte x) { + data = internal::r_coerce(x); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } + inline String& operator=(bool x) { + data = internal::r_coerce(x); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } + inline String& operator=(Rcomplex x) { + data = internal::r_coerce(x); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } + inline String& operator=(SEXP x) { + if (data != x) { + data = x; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + } + valid = true; + buffer_ready = false; + return *this; + } + inline String& operator=(const StringProxy& proxy) { + SEXP x = proxy.get(); + if (data != x) { + data = x; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(x); + } + valid = true; + buffer_ready = false; + return *this; + } + inline String& operator=(const String& other) { + if (other.buffer_ready) { + // Copy the buffer without creating a SEXP. + if (valid) { + Rcpp_PreciousRelease(token); + valid = false; + } + data = R_NilValue; + token = R_NilValue; + buffer = other.buffer; + buffer_ready = true; + enc = other.enc; + } else { + SEXP x = other.get_sexp(); + if (data != x) { + data = x; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(x); + } + valid = true; + buffer_ready = false; + } + return *this; + } + inline String& operator=(const std::string& s) { + buffer = s; + valid = false; + buffer_ready = true; + return *this; + } + inline String& operator=(String&& other) { + data = other.data; + token = other.token; + buffer = std::move(other.buffer); + valid = other.valid; + buffer_ready = other.buffer_ready; + enc = other.enc; + // Erase other. + other.data = R_NilValue; + other.token = R_NilValue; + other.buffer = std::string(); + other.valid = false; + other.buffer_ready = true; + other.enc = CE_UTF8; + return *this; + } + inline String& operator=(std::string&& s) { + buffer = s; + valid = false; + buffer_ready = true; + return *this; + } + inline String& operator=(const char* s) { + buffer = s; + valid = false; + buffer_ready = true; + return *this; + } private: template inline String& assign_wide_string(const T& s) { - data = Rcpp_ReplaceObject(data, internal::make_charsexp(s)); + data = internal::make_charsexp(s); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); valid = true; buffer_ready = false; return *this; @@ -191,7 +333,9 @@ namespace Rcpp { const char* buf = CHAR(data); std::wstring tmp(buf, buf + strlen(buf)); tmp += s; - data = Rcpp_ReplaceObject(data, internal::make_charsexp(tmp)); + data = internal::make_charsexp(tmp); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); valid = true; buffer_ready = false; return *this; @@ -205,7 +349,14 @@ namespace Rcpp { inline String& operator+=(const String& other) { RCPP_STRING_DEBUG("String::operator+=(const char*)"); if (is_na()) return *this; - if (other.is_na()) { data = Rcpp_ReplaceObject(data, NA_STRING); valid = true; buffer_ready = false; return *this; } + if (other.is_na()) { + data = NA_STRING; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } setBuffer(); buffer += other; valid = false; return *this; } @@ -213,7 +364,14 @@ namespace Rcpp { RCPP_STRING_DEBUG("String::operator+=(const StringProxy&)"); if (is_na()) return *this; SEXP proxy_sexp = proxy; - if (proxy_sexp == NA_STRING) { data = Rcpp_ReplaceObject(data, NA_STRING); valid = true; buffer_ready = false; return *this;} + if (proxy_sexp == NA_STRING) { + data = NA_STRING; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } setBuffer(); buffer += CHAR(proxy_sexp); valid = false; return *this; } @@ -221,14 +379,28 @@ namespace Rcpp { RCPP_STRING_DEBUG("String::operator+=(const StringProxy&)"); if (is_na()) return *this; SEXP proxy_sexp = proxy; - if (proxy_sexp == NA_STRING) { data = Rcpp_ReplaceObject(data, NA_STRING); valid = true; buffer_ready = false; return *this;} + if (proxy_sexp == NA_STRING) { + data = NA_STRING; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } setBuffer(); buffer += CHAR(proxy_sexp); valid = false; return *this; } inline String& operator+=(SEXP x) { RCPP_STRING_DEBUG("String::operator+=(SEXP)"); if (is_na()) return *this; - if (x == NA_STRING) { data = Rcpp_ReplaceObject(data, NA_STRING); valid = true; buffer_ready = false; return *this;} + if (x == NA_STRING) { + data = NA_STRING; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; + return *this; + } setBuffer(); buffer += CHAR(x); valid = false; return *this; } @@ -359,14 +531,30 @@ namespace Rcpp { inline void set_na() { - data = Rcpp_ReplaceObject(data, NA_STRING); - valid = true; buffer_ready = false; + data = NA_STRING; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + valid = true; + buffer_ready = false; } + inline SEXP get_sexp_impl() const { + + // workaround for h5 package (currently deprecated so updates + // to CRAN may not be timely) +#ifdef __H5Cpp_H + return Rf_mkCharCE(buffer.c_str(), enc); +#else + if (buffer.find('\0') != std::string::npos) + throw embedded_nul_in_string(); + return Rf_mkCharLenCE(buffer.c_str(), static_cast(buffer.size()), enc); +#endif + } + inline SEXP get_sexp() const { RCPP_STRING_DEBUG_1("String::get_sexp const (valid = %d) ", valid); - return valid ? data : Rf_mkCharCE(buffer.c_str(), enc); + return valid ? data : get_sexp_impl(); } inline SEXP get_sexp() { @@ -395,10 +583,14 @@ namespace Rcpp { enc = encoding; if (valid) { - data = Rcpp_ReplaceObject(data, Rf_mkCharCE(Rf_translateCharUTF8(data), encoding)); + // TODO: may longjmp on failure to translate? + const char* translated = Rf_translateCharUTF8(data); + data = Rf_mkCharCE(translated, encoding); + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); } else { - data = Rf_mkCharCE(buffer.c_str(), encoding); - Rcpp_PreserveObject(data); + data = get_sexp_impl(); + token = Rcpp_PreciousPreserve(data); valid = true; } } @@ -446,6 +638,7 @@ namespace Rcpp { /** the CHARSXP this String encapsulates */ SEXP data; + SEXP token; /** a buffer used to do string operations withough going back to the SEXP */ std::string buffer; @@ -469,8 +662,8 @@ namespace Rcpp { inline void setData() { RCPP_STRING_DEBUG("setData"); if (!valid) { - data = Rf_mkCharCE(buffer.c_str(), enc); - Rcpp_PreserveObject(data); + data = get_sexp_impl(); + token = Rcpp_PreciousPreserve(data); valid = true; } } @@ -517,7 +710,6 @@ namespace Rcpp { RCPP_STRING_DEBUG("wrap()"); Shield res(Rf_allocVector(STRSXP, 1)); SEXP data = object.get_sexp(); - Rcpp_PreserveObject(data); SET_STRING_ELT(res, 0, data); return res; } @@ -540,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 94ebe7fed..8c009ff04 100644 --- a/inst/include/Rcpp/StringTransformer.h +++ b/inst/include/Rcpp/StringTransformer.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // clone.h: Rcpp R/C++ interface class library -- clone RObject's // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -27,25 +26,25 @@ namespace Rcpp{ template - class StringTransformer : public std::unary_function{ + class StringTransformer : public std::function { public: StringTransformer( const UnaryOperator& op_ ): op(op_), buffer(){} ~StringTransformer(){} const char* operator()(const char* input ) { - buffer = input ; - std::transform( buffer.begin(), buffer.end(), buffer.begin(), op ) ; - return buffer.c_str() ; + buffer = input; + std::transform( buffer.begin(), buffer.end(), buffer.begin(), op ); + return buffer.c_str(); } private: - const UnaryOperator& op ; - std::string buffer ; - } ; + const UnaryOperator& op; + std::string buffer; + }; template StringTransformer make_string_transformer( const UnaryOperator& fun){ - return StringTransformer( fun ) ; + return StringTransformer( fun ); } } 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/Vector.h b/inst/include/Rcpp/Vector.h index e25be1d59..6c95ef8d9 100644 --- a/inst/include/Rcpp/Vector.h +++ b/inst/include/Rcpp/Vector.h @@ -1,5 +1,4 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // Vector.h: Rcpp R/C++ interface class library -- vectors // // Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois diff --git a/inst/include/Rcpp/XPtr.h b/inst/include/Rcpp/XPtr.h index 1e684c80c..17fb7cacd 100644 --- a/inst/include/Rcpp/XPtr.h +++ b/inst/include/Rcpp/XPtr.h @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- // // XPtr.h: Rcpp R/C++ interface class library -- smart external pointers // -// Copyright (C) 2009 - 2017 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2009 - 2020 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -27,24 +27,36 @@ namespace Rcpp { template -void standard_delete_finalizer(T* obj) { +void standard_delete_finalizer(T* obj) { // #nocov start delete obj; } template void finalizer_wrapper(SEXP p) { - if (TYPEOF(p) == EXTPTRSXP) { - T* ptr = (T*) R_ExternalPtrAddr(p); - RCPP_DEBUG_3("finalizer_wrapper<%s>(SEXP p = <%p>). ptr = %p", DEMANGLE(T), p, ptr) - Finalizer(ptr); - } -} + if (TYPEOF(p) != EXTPTRSXP) + return; + + T* ptr = (T*) R_ExternalPtrAddr(p); + RCPP_DEBUG_3("finalizer_wrapper<%s>(SEXP p = <%p>). ptr = %p", DEMANGLE(T), p, ptr) + + if (ptr == NULL) + return; + + // Clear before finalizing to avoid behavior like access of freed memory + R_ClearExternalPtr(p); + + Finalizer(ptr); +} // #nocov end template < typename T, template class StoragePolicy = PreserveStorage, void Finalizer(T*) = standard_delete_finalizer, - bool finalizeOnExit = false + #ifdef RCPP_USE_FINALIZE_ON_EXIT + bool finalizeOnExit = true + #else + bool finalizeOnExit = false + #endif > class XPtr : public StoragePolicy< XPtr >, @@ -63,14 +75,18 @@ class XPtr : * * @param xp external pointer to wrap */ - explicit XPtr(SEXP x, SEXP tag = R_NilValue, SEXP prot = R_NilValue) { - if (TYPEOF(x) != EXTPTRSXP) { - const char* fmt = "Expecting an external pointer: [type=%s]."; - throw ::Rcpp::not_compatible(fmt, Rf_type2char(TYPEOF(x))); - } + explicit XPtr(SEXP x) { checked_set(x); }; - Storage::set__(x); - R_SetExternalPtrTag( x, tag); + /** + * constructs a XPtr wrapping the external pointer (EXTPTRSXP SEXP) + * + * @param xp external pointer to wrap + * @param tag tag to assign to external pointer + * @param prot protected data to assign to external pointer + */ + explicit XPtr(SEXP x, SEXP tag, SEXP prot) { + checked_set(x); + R_SetExternalPtrTag(x, tag); R_SetExternalPtrProtected(x, prot); }; @@ -90,7 +106,7 @@ class XPtr : RCPP_DEBUG_2("XPtr(T* p = <%p>, bool set_delete_finalizer = %s, SEXP tag = R_NilValue, SEXP prot = R_NilValue)", p, (set_delete_finalizer ? "true" : "false")) Storage::set__(R_MakeExternalPtr((void*)p , tag, prot)); if (set_delete_finalizer) { - setDeleteFinalizer(); + setDeleteFinalizer(); // #nocov } } @@ -99,8 +115,8 @@ class XPtr : } XPtr& operator=(const XPtr& other) { - Storage::copy__(other); - return *this; + Storage::copy__(other); + return *this; } /** @@ -130,7 +146,7 @@ class XPtr : inline T* checked_get() const { T* ptr = get(); if (ptr == NULL) - throw ::Rcpp::exception("external pointer is not valid"); + throw ::Rcpp::exception("external pointer is not valid"); // #nocov return ptr; } @@ -150,10 +166,10 @@ class XPtr : return checked_get(); } - void setDeleteFinalizer() { + void setDeleteFinalizer() { // #nocov start R_RegisterCFinalizerEx(Storage::get__(), finalizer_wrapper, (Rboolean) finalizeOnExit); - } + } // #nocov end /** * Release the external pointer (if any) immediately. This will cause @@ -170,10 +186,9 @@ class XPtr : // Call the finalizer -- note that this implies that finalizers // need to be ready for a NULL external pointer value (our // default C++ finalizer is since delete NULL is a no-op). + // This clears the external pointer just before calling the finalizer, + // to avoid interesting behavior with co-dependent finalizers. finalizer_wrapper(Storage::get__()); - - // Clear the external pointer - R_ClearExternalPtr(Storage::get__()); } } @@ -182,6 +197,16 @@ class XPtr : } void update(SEXP) {} + +private: + inline void checked_set(SEXP x) { + if (TYPEOF(x) != EXTPTRSXP) { + const char* fmt = "Expecting an external pointer: [type=%s]."; // #nocov + throw ::Rcpp::not_compatible(fmt, Rf_type2char(TYPEOF(x))); // #nocov + } + Storage::set__(x); + } + }; } // namespace Rcpp 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..340d2ac7a 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 and Dirk Eddelbuettel // // 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,40 +37,20 @@ 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 diff --git a/inst/include/Rcpp/api/meat/is.h b/inst/include/Rcpp/api/meat/is.h index 2cc995026..93f6f9563 100644 --- a/inst/include/Rcpp/api/meat/is.h +++ b/inst/include/Rcpp/api/meat/is.h @@ -148,6 +148,8 @@ namespace Rcpp { return TYPEOF(x) == REALSXP && Rf_inherits(x, "POSIXt"); } +#ifndef RCPP_NO_MODULES + inline bool is_module_object_internal(SEXP obj, const char* clazz){ Environment env(obj); SEXP sexp = env.get(".cppclass"); @@ -161,6 +163,8 @@ namespace Rcpp { return is_module_object_internal(x, typeid(CLASS).name()); } +#endif + } // namespace internal } // namespace Rcpp diff --git a/inst/include/Rcpp/api/meat/meat.h b/inst/include/Rcpp/api/meat/meat.h index 76150caeb..323ad7e69 100644 --- a/inst/include/Rcpp/api/meat/meat.h +++ b/inst/include/Rcpp/api/meat/meat.h @@ -42,6 +42,10 @@ #include #include +#include + +#ifndef RCPP_NO_MODULES #include +#endif #endif diff --git a/inst/include/Rcpp/api/meat/message.h b/inst/include/Rcpp/api/meat/message.h new file mode 100644 index 000000000..59416f889 --- /dev/null +++ b/inst/include/Rcpp/api/meat/message.h @@ -0,0 +1,33 @@ + +// message.h: Rcpp R/C++ interface class library -- Wrapper for base::message +// +// Copyright (C) 2021 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_api_meat_message_h +#define Rcpp_api_meat_message_h + +namespace Rcpp { + + inline void message(SEXP s) { + Rcpp::Function msg = Rcpp::Environment::base_env()["message"]; + msg(s); + } + +} + +#endif diff --git a/inst/include/Rcpp/api/meat/proxy.h b/inst/include/Rcpp/api/meat/proxy.h index c00fa1249..e7dffde68 100644 --- a/inst/include/Rcpp/api/meat/proxy.h +++ b/inst/include/Rcpp/api/meat/proxy.h @@ -30,7 +30,7 @@ template template typename AttributeProxyPolicy::AttributeProxy& AttributeProxyPolicy::AttributeProxy::operator=(const T& rhs) { - set(Shield(wrap(rhs))); + set(wrap(rhs)); return *this; } 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/clone.h b/inst/include/Rcpp/clone.h index a9a133e1a..f2a1e911f 100644 --- a/inst/include/Rcpp/clone.h +++ b/inst/include/Rcpp/clone.h @@ -31,8 +31,9 @@ namespace Rcpp{ - T has a SEXP constructor */ template T clone(const T& object) { - SEXP x = const_cast(object) ; - return T( Rf_duplicate( x ) ) ; + Shield x(const_cast(object)); + Shield copy(Rf_duplicate(x)); + return T((SEXP)copy); } } // namespace Rcpp diff --git a/inst/include/Rcpp/config.h b/inst/include/Rcpp/config.h index f871e3449..c1eca013b 100644 --- a/inst/include/Rcpp/config.h +++ b/inst/include/Rcpp/config.h @@ -1,7 +1,8 @@ + // config.h: Rcpp R/C++ interface class library -- Rcpp configuration // -// Copyright (C) 2010 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -26,9 +27,11 @@ #define RcppDevVersion(maj, min, rev, dev) (((maj)*1000000) + ((min)*10000) + ((rev)*100) + (dev)) // the currently released version -#define RCPP_VERSION Rcpp_Version(0,12,19) +#define RCPP_VERSION Rcpp_Version(1,1,1) +#define RCPP_VERSION_STRING "1.1.1" -// the current source snapshot -#define RCPP_DEV_VERSION RcppDevVersion(0,12,19,3) +// the current source snapshot (using four components, if a fifth is used in DESCRIPTION we ignore it) +#define RCPP_DEV_VERSION RcppDevVersion(1,1,1,1) +#define RCPP_DEV_VERSION_STRING "1.1.1.1" #endif 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 6b8c793b9..2311442e3 100644 --- a/inst/include/Rcpp/exceptions.h +++ b/inst/include/Rcpp/exceptions.h @@ -1,8 +1,9 @@ -// -*- 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) 2010 - 2020 Dirk Eddelbuettel and Romain Francois +// 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. // @@ -28,21 +29,22 @@ #define RCPP_DEFAULT_INCLUDE_CALL true #endif -#define GET_STACKTRACE() stack_trace( __FILE__, __LINE__ ) +#define GET_STACKTRACE() R_NilValue namespace Rcpp { + // Throwing an exception must be thread-safe to avoid surprises w/ OpenMP. class exception : public std::exception { public: explicit exception(const char* message_, bool include_call = RCPP_DEFAULT_INCLUDE_CALL) : // #nocov start message(message_), - include_call_(include_call){ - rcpp_set_stack_trace(Shield(stack_trace())); + include_call_(include_call) { + record_stack_trace(); } exception(const char* message_, const char*, int, bool include_call = RCPP_DEFAULT_INCLUDE_CALL) : message(message_), - include_call_(include_call){ - rcpp_set_stack_trace(Shield(stack_trace())); + include_call_(include_call) { + record_stack_trace(); } bool include_call() const { return include_call_; @@ -51,9 +53,12 @@ namespace Rcpp { virtual const char* what() const throw() { return message.c_str(); // #nocov end } + inline void copy_stack_trace_to_r() const; private: std::string message; bool include_call_; + std::vector stack; + inline void record_stack_trace(); }; // simple helper @@ -105,9 +110,9 @@ namespace Rcpp { // Variadic / code generated version of the warning and stop functions // can be found within the respective C++11 or C++98 exceptions.h - // included below + // included below. inline void warning(const std::string& message) { // #nocov start - Rf_warning(message.c_str()); + ::Rf_warning("%s", message.c_str()); } // #nocov end inline void NORET stop(const std::string& message) { // #nocov start @@ -130,7 +135,7 @@ inline SEXP longjumpSentinel(SEXP token) { return sentinel; } -inline bool isLongjumpSentinel(SEXP x) { +inline bool isLongjumpSentinel(SEXP x) { // #nocov start return Rf_inherits(x, "Rcpp:longjumpSentinel") && TYPEOF(x) == VECSXP && @@ -146,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 Rf_error("Internal error: Rcpp longjump failed to resume"); } @@ -166,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; \ + }; -// 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 + template + inline void warning(const char* fmt, Args&&... args ) { + Rf_warning("%s", tfm::format(fmt, std::forward(args)... ).c_str()); + } // #nocov end -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{ \ @@ -200,7 +214,7 @@ namespace Rcpp { virtual const char* what() const throw() { return __MESSAGE__ ; } \ } ; - RCPP_SIMPLE_EXCEPTION_CLASS(not_a_matrix, "Not a matrix.") // #nocov start + RCPP_SIMPLE_EXCEPTION_CLASS(not_a_matrix, "Not a matrix.") // #nocov start RCPP_SIMPLE_EXCEPTION_CLASS(parse_error, "Parse error.") RCPP_SIMPLE_EXCEPTION_CLASS(not_s4, "Not an S4 object.") RCPP_SIMPLE_EXCEPTION_CLASS(not_reference, "Not an S4 object of a reference class.") @@ -208,6 +222,7 @@ namespace Rcpp { RCPP_SIMPLE_EXCEPTION_CLASS(no_such_field, "No such field.") // not used internally RCPP_SIMPLE_EXCEPTION_CLASS(no_such_function, "No such function.") RCPP_SIMPLE_EXCEPTION_CLASS(unevaluated_promise, "Promise not yet evaluated.") + RCPP_SIMPLE_EXCEPTION_CLASS(embedded_nul_in_string, "Embedded NUL in string.") // Promoted RCPP_EXCEPTION_CLASS(no_such_slot, "No such slot") @@ -220,10 +235,10 @@ namespace Rcpp { RCPP_EXCEPTION_CLASS(binding_is_locked, "Binding is locked") RCPP_EXCEPTION_CLASS(no_such_namespace, "No such namespace") RCPP_EXCEPTION_CLASS(function_not_exported, "Function not exported") - RCPP_EXCEPTION_CLASS(eval_error, "Evaluation error") // #nocov end + RCPP_EXCEPTION_CLASS(eval_error, "Evaluation error") // Promoted - RCPP_ADVANCED_EXCEPTION_CLASS(not_compatible, "Not compatible" ) + RCPP_ADVANCED_EXCEPTION_CLASS(not_compatible, "Not compatible" ) // #nocov end RCPP_ADVANCED_EXCEPTION_CLASS(index_out_of_bounds, "Index is out of bounds") #undef RCPP_SIMPLE_EXCEPTION_CLASS @@ -317,7 +332,11 @@ inline SEXP make_condition(const std::string& ex_msg, SEXP call, SEXP cppstack, template inline SEXP exception_to_condition_template( const Exception& ex, bool include_call) { +#ifndef RCPP_NO_RTTI std::string ex_class = demangle( typeid(ex).name() ) ; +#else + std::string ex_class = ""; +#endif std::string ex_msg = ex.what() ; Rcpp::Shelter shelter; @@ -336,7 +355,8 @@ inline SEXP exception_to_condition_template( const Exception& ex, bool include_c } inline SEXP rcpp_exception_to_r_condition(const Rcpp::exception& ex) { - return exception_to_condition_template(ex, ex.include_call()); + ex.copy_stack_trace_to_r(); + return exception_to_condition_template(ex, ex.include_call()); } inline SEXP exception_to_r_condition( const std::exception& ex){ @@ -368,7 +388,10 @@ inline SEXP exception_to_try_error( const std::exception& ex){ } std::string demangle( const std::string& name) ; +#ifndef RCPP_NO_RTTI #define DEMANGLE(__TYPE__) demangle( typeid(__TYPE__).name() ).c_str() +#endif + inline void forward_exception_to_r(const std::exception& ex){ SEXP stop_sym = Rf_install( "stop" ) ; 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 new file mode 100644 index 000000000..9fe071518 --- /dev/null +++ b/inst/include/Rcpp/exceptions_impl.h @@ -0,0 +1,120 @@ +// exceptions_impl.h: Rcpp R/C++ interface class library -- exceptions +// +// Copyright (C) 2012 - 2019 Dirk Eddelbuettel and Romain Francois +// 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. +// +// 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__exceptions_impl__h +#define Rcpp__exceptions_impl__h + +// enable demangler on platforms where execinfo.h is present +// and that are not actively blacklisted +#ifndef RCPP_DEMANGLER_ENABLED +// 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 { + + // Extract mangled name e.g. ./test(baz+0x14)[0x400962] +#if RCPP_DEMANGLER_ENABLED + static inline std::string demangler_one(const char* input) { // #nocov start + + static std::string buffer; + + buffer = input; + size_t last_open = buffer.find_last_of('('); + size_t last_close = buffer.find_last_of(')'); + if (last_open == std::string::npos || + last_close == std::string::npos) { + return input; // #nocov + } + std::string function_name = buffer.substr(last_open + 1, last_close - last_open - 1); + // Strip the +0x14 (if it exists, which it does not in earlier versions of gcc) + size_t function_plus = function_name.find_last_of('+'); + if (function_plus != std::string::npos) { + function_name.resize(function_plus); + } + buffer.replace(last_open + 1, function_name.size(), demangle(function_name)); + + return buffer; + + } +#endif + + // thread-safe; invoked prior to throwing the exception + inline void exception::record_stack_trace() + { +#if RCPP_DEMANGLER_ENABLED + /* inspired from http://tombarta.wordpress.com/2008/08/01/c-stack-traces-with-gcc/ */ + const size_t max_depth = 100; + int stack_depth; + void *stack_addrs[max_depth]; + + stack_depth = backtrace(stack_addrs, max_depth); + char **stack_strings = backtrace_symbols(stack_addrs, stack_depth); + + std::transform(stack_strings + 1, stack_strings + stack_depth, + std::back_inserter(stack), demangler_one); + free(stack_strings); // malloc()ed by backtrace_symbols +#endif + } + + // not thread-safe; invoked after catching the exception + inline void exception::copy_stack_trace_to_r() const + { + if (!stack.size()) { + rcpp_set_stack_trace(R_NilValue); + return; + } + + CharacterVector res(stack.size()); + std::copy(stack.begin(), stack.end(), res.begin()); + List trace = List::create(_["file" ] = "", + _["line" ] = -1, + _["stack"] = res); + trace.attr("class") = "Rcpp_stack_trace"; + rcpp_set_stack_trace(trace); // #nocov end + } + +} + +#endif 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 d907cebdf..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 Rcpp_fast_eval(Rf_lang2(Storage::get__(), pairlist(PARAMETERS)), R_GlobalEnv); - } - -*/ - template - SEXP operator()(const T1& t1) const { - return Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), pairlist(t1)), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2) const { - return Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), pairlist(t1, t2)), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3) const { - return Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), pairlist(t1, t2, t3)), R_GlobalEnv); - } - - template - SEXP operator()(const T1& t1, const T2& t2, const T3& t3, const T4& t4) const { - return Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 Rcpp_fast_eval(Rcpp_lcons(Storage::get__(), 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 e2db17aec..000000000 --- a/inst/include/Rcpp/generated/InternalFunction__ctors.h +++ /dev/null @@ -1,490 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// InternalFunction_Impl_ctors.h -- generated helper code for InternalFunction__ctors.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__InternalFunction_Impl_ctors_h -#define Rcpp__generated__InternalFunction_Impl_ctors_h - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(void)) { - set(XPtr >(new CppFunction0(fun), false)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0)) { - set(XPtr >(new CppFunction1(fun), false)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1)) { - set(XPtr >(new CppFunction2(fun), false)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2)) { - set(XPtr >(new CppFunction3(fun), false)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3)) { - set(XPtr >(new CppFunction4(fun), false)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4)) { - set(XPtr >(new CppFunction5(fun), false)); - } - - - - template - InternalFunction_Impl(RESULT_TYPE (*fun)(U0 u0, U1 u1, U2 u2, U3 u3, U4 u4, U5 u5)) { - set(XPtr >(new CppFunction6(fun), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - - - 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), false)); - } - - -#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 a882445a5..000000000 --- a/inst/include/Rcpp/generated/Vector__create.h +++ /dev/null @@ -1,1229 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// Vector__create.h: Rcpp R/C++ interface class library -- generated helper code for Vector.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__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){ - return create__dispatch( typename traits::integral_constant::value || traits::is_named::value - >::type(), t1, t2 ) ; - } - -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 - 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 ; - } - -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){ - 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 ; - } - -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 e5a36c67b..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,7 +70,15 @@ namespace Rcpp { return grow(Rf_mkString(head), y); } - #include + 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 9c32c8541..6bc73ed3d 100644 --- a/inst/include/Rcpp/hash/IndexHash.h +++ b/inst/include/Rcpp/hash/IndexHash.h @@ -1,11 +1,11 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 4 -*- -// + // IndexHash.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) 2014 Dirk Eddelbuettel, Romain Francois and Kevin Ushey +// Copyright (C) 2010, 2011 Simon Urbanek +// Copyright (C) 2012 - 2013 Dirk Eddelbuettel and Romain Francois +// 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. // @@ -43,7 +43,7 @@ namespace Rcpp{ namespace sugar{ #ifndef RCPP_HASH - #define RCPP_HASH(X) (3141592653U * ((unsigned int)(X)) >> (32 - k)) + #define RCPP_HASH(X) (3141592653U * ((uint32_t)(X)) >> (32 - k)) #endif template @@ -100,7 +100,7 @@ namespace Rcpp{ } inline bool contains(STORAGE val) const { - return get_index(val) != NA_INTEGER ; + return get_index(val) != static_cast(NA_INTEGER); } inline int size() const { @@ -160,17 +160,19 @@ 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++] ; - unsigned int addr = get_addr(val) ; + STORAGE val = normalize(src[i++]); + uint32_t addr = get_addr(val) ; while (data[addr] && not_equal( src[data[addr] - 1], val)) { addr++; - if (addr == static_cast(m)) { + if (addr == static_cast(m)) { addr = 0; } } @@ -185,46 +187,51 @@ namespace Rcpp{ } /* NOTE: we are returning a 1-based index ! */ - inline unsigned int get_index(STORAGE value) const { - unsigned int addr = get_addr(value) ; + inline uint32_t get_index(STORAGE value) const { + uint32_t addr = get_addr(value) ; while (data[addr]) { if (src[data[addr] - 1] == value) return data[addr]; addr++; - if (addr == static_cast(m)) addr = 0; + if (addr == static_cast(m)) addr = 0; } return NA_INTEGER; } // defined below - unsigned int get_addr(STORAGE value) const ; + uint32_t get_addr(STORAGE value) const ; } ; template <> - inline unsigned int IndexHash::get_addr(int value) const { + 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) ; } template <> - inline unsigned int IndexHash::get_addr(double val) const { - unsigned int addr; + inline uint32_t IndexHash::get_addr(double val) const { + uint32_t addr; union dint_u { double d; - unsigned int u[2]; + 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 ; } template <> - inline unsigned int IndexHash::get_addr(SEXP value) const { + inline uint32_t IndexHash::get_addr(SEXP value) const { intptr_t val = (intptr_t) value; - unsigned int addr; + uint32_t addr; #if (defined _LP64) || (defined __LP64__) || (defined WIN64) addr = RCPP_HASH((val & 0xffffffff) ^ (val >> 32)); #else @@ -238,4 +245,3 @@ namespace Rcpp{ } // Rcpp #endif - 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/Proxy_Iterator.h b/inst/include/Rcpp/internal/Proxy_Iterator.h index bc94f112b..6ba891765 100644 --- a/inst/include/Rcpp/internal/Proxy_Iterator.h +++ b/inst/include/Rcpp/internal/Proxy_Iterator.h @@ -1,6 +1,4 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -/* :tabSize=4:indentSize=4:noTabs=false:folding=explicit:collapseFolds=1: */ -// + // Proxy_Iterator.h: Rcpp R/C++ interface class library -- // // Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois @@ -31,7 +29,7 @@ class Proxy_Iterator { public: typedef PROXY& reference ; typedef PROXY* pointer ; - typedef int difference_type ; + typedef R_xlen_t difference_type ; typedef PROXY value_type; typedef std::random_access_iterator_tag iterator_category ; @@ -122,4 +120,3 @@ class Proxy_Iterator { } #endif - diff --git a/inst/include/Rcpp/internal/SEXP_Iterator.h b/inst/include/Rcpp/internal/SEXP_Iterator.h index 62e604d23..fbb8e2ad4 100644 --- a/inst/include/Rcpp/internal/SEXP_Iterator.h +++ b/inst/include/Rcpp/internal/SEXP_Iterator.h @@ -37,7 +37,7 @@ class SEXP_Iterator { SEXP_Iterator( ): ptr(){} ; SEXP_Iterator( const SEXP_Iterator& other) : ptr(other.ptr){} ; - SEXP_Iterator( const VECTOR& vec ) : ptr( get_vector_ptr(vec) ){} ; + SEXP_Iterator( const VECTOR& vec ) : ptr( RCPP_VECTOR_PTR(vec) ){} ; SEXP_Iterator& operator=(const SEXP_Iterator& other){ ptr = other.ptr ; return *this ;} diff --git a/inst/include/Rcpp/internal/call.h b/inst/include/Rcpp/internal/call.h new file mode 100644 index 000000000..9a75e1b11 --- /dev/null +++ b/inst/include/Rcpp/internal/call.h @@ -0,0 +1,53 @@ +#ifndef RCPP_INTERNAL_CALL_H +#define RCPP_INTERNAL_CALL_H + +#include +#include + +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. + */ +template ::value>::type* = nullptr> +SEXP call_impl(const F& fun, SEXP* args, type_pack, + traits::index_sequence) { + RESULT_TYPE res = fun((typename traits::input_parameter::type(args[Is]))...); + return Rcpp::module_wrap(res); +} + +template ::value>::type* = nullptr> +SEXP call_impl(const F& fun, SEXP* args, type_pack, + traits::index_sequence) { + fun((typename traits::input_parameter::type(args[Is]))...); + return R_NilValue; +} +} // namespace internal + +/** + * 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. + */ +template +SEXP call(const F& fun, SEXP* args) { + return internal::call_impl(fun, args, + internal::type_pack{}, + traits::make_index_sequence{}); +} +} // namespace Rcpp + +#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 e433127d7..04d899433 100644 --- a/inst/include/Rcpp/internal/export.h +++ b/inst/include/Rcpp/internal/export.h @@ -1,6 +1,4 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -/* :tabSize=4:indentSize=4:noTabs=false:folding=explicit:collapseFolds=1: */ -// + // export.h: Rcpp R/C++ interface class library -- // // Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois @@ -79,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(double x){ template <> inline const char* coerce_to_string(int from) { static char buffer[NB] ; - snprintf( buffer, NB, "%*d", integer_width(from), from ); + snprintf(buffer, NB, "%*d", integer_width(from), from); return buffer ; } template <> inline const char* coerce_to_string(Rbyte from){ static char buff[3]; - ::sprintf(buff, "%02x", from); - return buff ; + snprintf(buff, 3, "%02x", from); + return buff; } template <> inline const char* coerce_to_string(int from){ diff --git a/inst/include/Rcpp/internal/r_vector.h b/inst/include/Rcpp/internal/r_vector.h index efdf3c8e3..589c75fed 100644 --- a/inst/include/Rcpp/internal/r_vector.h +++ b/inst/include/Rcpp/internal/r_vector.h @@ -32,6 +32,21 @@ typename Rcpp::traits::storage_type::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/iostream/Rstreambuf.h b/inst/include/Rcpp/iostream/Rstreambuf.h index 6fe409a91..1cb1669ac 100644 --- a/inst/include/Rcpp/iostream/Rstreambuf.h +++ b/inst/include/Rcpp/iostream/Rstreambuf.h @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- // // Rstreambuf.h: Rcpp R/C++ interface class library -- stream buffer // -// Copyright (C) 2011 - 2017 Dirk Eddelbuettel, Romain Francois and Jelmer Ypma +// Copyright (C) 2011 - 2020 Dirk Eddelbuettel, Romain Francois and Jelmer Ypma +// Copyright (C) 2021 - 2023 Dirk Eddelbuettel, Romain Francois, Jelmer Ypma and Iñaki Ucar // // This file is part of Rcpp. // @@ -49,11 +49,11 @@ namespace Rcpp { }; // #nocov start template <> inline std::streamsize Rstreambuf::xsputn(const char *s, std::streamsize num) { - Rprintf("%.*s", num, s); + Rprintf("%.*s", static_cast(num), s); return num; } template <> inline std::streamsize Rstreambuf::xsputn(const char *s, std::streamsize num) { - REprintf("%.*s", num, s); + REprintf("%.*s", static_cast(num), s); return num; } @@ -80,9 +80,14 @@ namespace Rcpp { ::R_FlushConsole(); return 0; } // #nocov end - static Rostream Rcout; - static Rostream Rcerr; +#ifdef RCPP_USE_GLOBAL_ROSTREAM + extern Rostream& Rcout; + extern Rostream& Rcerr; +#else + static Rostream Rcout; + static Rostream Rcerr; +#endif } diff --git a/inst/include/Rcpp/lang.h b/inst/include/Rcpp/lang.h index 025aafb70..8e9031acf 100644 --- a/inst/include/Rcpp/lang.h +++ b/inst/include/Rcpp/lang.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // lang.h: Rcpp R/C++ interface class library -- extra lang_* functions // -// Copyright (C) 2011 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2011 - 2020 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -24,347 +23,275 @@ #define Rcpp_list1 Rf_list1 #define Rcpp_lang1 Rf_lang1 +#define Rcpp_lang2 Rf_lang2 +#define Rcpp_lang3 Rf_lang3 +#define Rcpp_lang4 Rf_lang4 +#define Rcpp_lang5 Rf_lang5 +#define Rcpp_lang6 Rf_lang6 + +#define Rcpp_lcons Rf_lcons namespace Rcpp { -inline SEXP Rcpp_lcons(SEXP car, SEXP cdr){ - Shield out( Rf_lcons( car, cdr ) ); - return out ; +inline SEXP Rcpp_list2(SEXP x0, SEXP x1) { + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list1(x1)); + UNPROTECT(1); + return x0; } -inline SEXP Rcpp_list2( SEXP x0, SEXP x1 ){ - Shield out( Rf_cons(x0, Rcpp_list1(x1)) ); - return out; +inline SEXP Rcpp_list3(SEXP x0, SEXP x1, SEXP x2) { + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list2(x1, x2)); + UNPROTECT(1); + return x0; } -inline SEXP Rcpp_lang2( SEXP x0, SEXP x1 ){ - Shield out( Rf_lcons(x0, Rcpp_list1(x1)) ); - return out; +inline SEXP Rcpp_list4(SEXP x0, SEXP x1, SEXP x2, SEXP x3) { + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list3(x1, x2, x3)); + UNPROTECT(1); + return x0; } - - - - -inline SEXP Rcpp_list3( SEXP x0, SEXP x1, SEXP x2 ) -{ - Shield out( Rf_cons(x0, Rcpp_list2(x1, x2)) ); - return out; +inline SEXP Rcpp_list5(SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4) { + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list4(x1, x2, x3, x4)); + UNPROTECT(1); + return x0; } -inline SEXP Rcpp_lang3( SEXP x0, SEXP x1, SEXP x2 ) -{ - Shield out(Rf_lcons(x0, Rcpp_list2(x1, x2)) ); - return out; -} - - - - - -inline SEXP Rcpp_list4( SEXP x0, SEXP x1, SEXP x2, SEXP x3 ) -{ - Shield out( Rf_cons(x0, Rcpp_list3(x1, x2, x3)) ); - - return out; -} - -inline SEXP Rcpp_lang4( SEXP x0, SEXP x1, SEXP x2, SEXP x3 ) -{ - Shield out( Rf_lcons(x0, Rcpp_list3(x1, x2, x3)) ); - - return out; -} - - - - - -inline SEXP Rcpp_list5( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4 ) -{ - Shield out( Rf_cons(x0, Rcpp_list4(x1, x2, x3, x4)) ); - - return out; -} - -inline SEXP Rcpp_lang5( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4 ) -{ - Shield out( Rf_lcons(x0, Rcpp_list4(x1, x2, x3, x4)) ); - - return out; +inline SEXP Rcpp_list6(SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5) { + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list5(x1, x2, x3, x4, x5)); + UNPROTECT(1); + return x0; } - - - - -inline SEXP Rcpp_list6( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5 ) -{ - Shield out( Rf_cons(x0, Rcpp_list5(x1, x2, x3, x4, x5)) ); - - return out; -} - -inline SEXP Rcpp_lang6( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5 ) -{ - Shield out( Rf_lcons(x0, Rcpp_list5(x1, x2, x3, x4, x5)) ); - - return out; -} - - - - - inline SEXP Rcpp_list7( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6 ) { - Shield out( Rf_cons(x0, Rcpp_list6(x1, x2, x3, x4, x5, x6)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list6(x1, x2, x3, x4, x5, x6)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang7( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6 ) { - Shield out( Rf_lcons(x0, Rcpp_list6(x1, x2, x3, x4, x5, x6)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list6(x1, x2, x3, x4, x5, x6)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list8( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7 ) { - Shield out( Rf_cons(x0, Rcpp_list7(x1, x2, x3, x4, x5, x6, x7)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list7(x1, x2, x3, x4, x5, x6, x7)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang8( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7 ) { - Shield out( Rf_lcons(x0, Rcpp_list7(x1, x2, x3, x4, x5, x6, x7)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list7(x1, x2, x3, x4, x5, x6, x7)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list9( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8 ) { - Shield out( Rf_cons(x0, Rcpp_list8(x1, x2, x3, x4, x5, x6, x7, x8)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list8(x1, x2, x3, x4, x5, x6, x7, x8)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang9( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8 ) { - Shield out( Rf_lcons(x0, Rcpp_list8(x1, x2, x3, x4, x5, x6, x7, x8)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list8(x1, x2, x3, x4, x5, x6, x7, x8)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list10( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9 ) { - Shield out( Rf_cons(x0, Rcpp_list9(x1, x2, x3, x4, x5, x6, x7, x8, x9)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list9(x1, x2, x3, x4, x5, x6, x7, x8, x9)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang10( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9 ) { - Shield out( Rf_lcons(x0, Rcpp_list9(x1, x2, x3, x4, x5, x6, x7, x8, x9)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list9(x1, x2, x3, x4, x5, x6, x7, x8, x9)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list11( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10 ) { - Shield out( Rf_cons(x0, Rcpp_list10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang11( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10 ) { - Shield out( Rf_lcons(x0, Rcpp_list10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list10(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list12( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11 ) { - Shield out( Rf_cons(x0, Rcpp_list11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang12( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11 ) { - Shield out( Rf_lcons(x0, Rcpp_list11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list11(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list13( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12 ) { - Shield out( Rf_cons(x0, Rcpp_list12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang13( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12 ) { - Shield out( Rf_lcons(x0, Rcpp_list12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list12(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list14( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13 ) { - Shield out( Rf_cons(x0, Rcpp_list13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang14( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13 ) { - Shield out( Rf_lcons(x0, Rcpp_list13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list13(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list15( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14 ) { - Shield out( Rf_cons(x0, Rcpp_list14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang15( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14 ) { - Shield out( Rf_lcons(x0, Rcpp_list14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list14(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list16( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15 ) { - Shield out( Rf_cons(x0, Rcpp_list15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang16( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15 ) { - Shield out( Rf_lcons(x0, Rcpp_list15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list15(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list17( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16 ) { - Shield out( Rf_cons(x0, Rcpp_list16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang17( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16 ) { - Shield out( Rf_lcons(x0, Rcpp_list16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list16(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list18( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16, SEXP x17 ) { - Shield out( Rf_cons(x0, Rcpp_list17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang18( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16, SEXP x17 ) { - Shield out( Rf_lcons(x0, Rcpp_list17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list17(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list19( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16, SEXP x17, SEXP x18 ) { - Shield out( Rf_cons(x0, Rcpp_list18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang19( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16, SEXP x17, SEXP x18 ) { - Shield out( Rf_lcons(x0, Rcpp_list18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list18(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18)); + UNPROTECT(1); + return x0; } - - - - inline SEXP Rcpp_list20( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16, SEXP x17, SEXP x18, SEXP x19 ) { - Shield out( Rf_cons(x0, Rcpp_list19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)) ); - - return out; + PROTECT(x0); + x0 = Rf_cons(x0, Rcpp_list19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)); + UNPROTECT(1); + return x0; } inline SEXP Rcpp_lang20( SEXP x0, SEXP x1, SEXP x2, SEXP x3, SEXP x4, SEXP x5, SEXP x6, SEXP x7, SEXP x8, SEXP x9, SEXP x10, SEXP x11, SEXP x12, SEXP x13, SEXP x14, SEXP x15, SEXP x16, SEXP x17, SEXP x18, SEXP x19 ) { - Shield out( Rf_lcons(x0, Rcpp_list19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)) ); - - return out; + PROTECT(x0); + x0 = Rf_lcons(x0, Rcpp_list19(x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19)); + UNPROTECT(1); + return x0; } } #endif - 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/debug.h b/inst/include/Rcpp/macros/debug.h index a30adaad5..a6c96d77e 100644 --- a/inst/include/Rcpp/macros/debug.h +++ b/inst/include/Rcpp/macros/debug.h @@ -33,12 +33,12 @@ #if RCPP_DEBUG_LEVEL > 0 - #define RCPP_DEBUG( MSG ) Rprintf( "%40s:%4d %s\n" , short_file_name(__FILE__), __LINE__, MSG ) ; - #define RCPP_DEBUG_1( fmt, MSG ) Rprintf( "%40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, MSG ) ; - #define RCPP_DEBUG_2( fmt, M1, M2 ) Rprintf( "%40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2 ) ; - #define RCPP_DEBUG_3( fmt, M1, M2, M3 ) Rprintf( "%40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2, M3) ; - #define RCPP_DEBUG_4( fmt, M1, M2, M3, M4 ) Rprintf( "%40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2, M3, M4) ; - #define RCPP_DEBUG_5( fmt, M1, M2, M3, M4, M5 ) Rprintf( "%40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2, M3, M4, M5) ; + #define RCPP_DEBUG( MSG ) Rprintf( "%40s:%4d %s\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG ) ; + #define RCPP_DEBUG_1( fmt, MSG ) Rprintf( "%40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG ) ; + #define RCPP_DEBUG_2( fmt, M1, M2 ) Rprintf( "%40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2 ) ; + #define RCPP_DEBUG_3( fmt, M1, M2, M3 ) Rprintf( "%40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3) ; + #define RCPP_DEBUG_4( fmt, M1, M2, M3, M4 ) Rprintf( "%40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3, M4) ; + #define RCPP_DEBUG_5( fmt, M1, M2, M3, M4, M5 ) Rprintf( "%40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3, M4, M5) ; #else #define RCPP_DEBUG( MSG ) #define RCPP_DEBUG_1( fmt, MSG ) @@ -52,49 +52,49 @@ #define RCPP_DEBUG_MODULE( MSG ) { \ Rcpp::Module * mod__ = getCurrentScope() ; \ if( mod__ ){ \ - Rprintf( "[module (%s) <%p> ] %40s:%4d %s\n" , mod__->name.c_str(), mod__, short_file_name(__FILE__), __LINE__, MSG ) ;\ + Rprintf( "[module (%s) <%p> ] %40s:%4d %s\n" , mod__->name.c_str(), mod__, ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG ) ;\ } else { \ - Rprintf( "[module () ] %40s:%4d %s\n" , short_file_name(__FILE__), __LINE__, MSG ) ; \ + Rprintf( "[module () ] %40s:%4d %s\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG ) ; \ } \ } #define RCPP_DEBUG_MODULE_1( fmt, MSG ) { \ Rcpp::Module * mod__ = getCurrentScope() ; \ if( mod__ ){ \ - Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, short_file_name(__FILE__), __LINE__, MSG ) ;\ + Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG ) ;\ } else { \ - Rprintf( "[module () ] %40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, MSG ) ; \ + Rprintf( "[module () ] %40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, MSG ) ; \ } \ } #define RCPP_DEBUG_MODULE_2( fmt, M1, M2 ) { \ Rcpp::Module * mod__ = getCurrentScope() ; \ if( mod__ ){ \ - Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, short_file_name(__FILE__), __LINE__, M1, M2 ) ;\ + Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2 ) ;\ } else { \ - Rprintf( "[module () ] %40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2 ) ; \ + Rprintf( "[module () ] %40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2 ) ; \ } \ } #define RCPP_DEBUG_MODULE_3( fmt, M1, M2, M3 ) { \ Rcpp::Module * mod__ = getCurrentScope() ; \ if( mod__ ){ \ - Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, short_file_name(__FILE__), __LINE__, M1, M2, M3 ) ;\ + Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3 ) ;\ } else { \ - Rprintf( "[module () ] %40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2, M3 ) ; \ + Rprintf( "[module () ] %40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3 ) ; \ } \ } #define RCPP_DEBUG_MODULE_4( fmt, M1, M2, M3, M4 ) { \ Rcpp::Module * mod__ = getCurrentScope() ; \ if( mod__ ) { \ - Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, short_file_name(__FILE__), __LINE__, M1, M2, M3, M4 ) ;\ + Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3, M4 ) ;\ } else { \ - Rprintf( "[module () ] %40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2, M3, M4 ) ; \ + Rprintf( "[module () ] %40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3, M4 ) ; \ } \ } #define RCPP_DEBUG_MODULE_5( fmt, M1, M2, M3, M4, M5 ) { \ Rcpp::Module * mod__ = getCurrentScope() ; \ if( mod__ ){ \ - Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, short_file_name(__FILE__), __LINE__, M1, M2, M3, M4, M5 ) ;\ + Rprintf( "[module (%s) <%p> ] %40s:%4d " fmt "\n" , mod__->name.c_str(), mod__, ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3, M4, M5 ) ;\ } else { \ - Rprintf( "[module () ] %40s:%4d " fmt "\n" , short_file_name(__FILE__), __LINE__, M1, M2, M3, M4, M5 ) ; \ + Rprintf( "[module () ] %40s:%4d " fmt "\n" , ::Rcpp::internal::debug::short_file_name(__FILE__).c_str(), __LINE__, M1, M2, M3, M4, M5 ) ; \ } \ } #else 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/macros.h b/inst/include/Rcpp/macros/macros.h index edc50b2e8..f3244e1c0 100644 --- a/inst/include/Rcpp/macros/macros.h +++ b/inst/include/Rcpp/macros/macros.h @@ -22,6 +22,25 @@ #ifndef Rcpp_macros_macros_h #define Rcpp_macros_macros_h +#include + +namespace Rcpp { +namespace internal { +namespace debug { + +inline std::string short_file_name(const char* file) +{ + std::string f(file); + size_t index = f.find("/include/"); + if (index != std::string::npos) + f = f.substr(index + 9); + return f; +} + +} // namespace debug +} // namespace internal +} // namespace Rcpp + #define RCPP_DECORATE(__FUN__) __FUN__##__rcpp__wrapper__ #define RCPP_GET_NAMES(x) Rf_getAttrib(x, R_NamesSymbol) #define RCPP_GET_CLASS(x) Rf_getAttrib(x, R_ClassSymbol) @@ -29,9 +48,11 @@ #ifndef BEGIN_RCPP #define BEGIN_RCPP \ int rcpp_output_type = 0 ; \ + int nprot = 0; \ (void)rcpp_output_type; \ SEXP rcpp_output_condition = R_NilValue ; \ (void)rcpp_output_condition; \ + static SEXP stop_sym = Rf_install("stop"); \ try { #endif @@ -48,26 +69,30 @@ catch(Rcpp::exception& __ex__) { \ rcpp_output_type = 2 ; \ rcpp_output_condition = PROTECT(rcpp_exception_to_r_condition(__ex__)) ; \ + ++nprot; \ } \ catch( std::exception& __ex__ ){ \ rcpp_output_type = 2 ; \ rcpp_output_condition = PROTECT(exception_to_r_condition(__ex__)) ; \ + ++nprot; \ } \ catch( ... ){ \ rcpp_output_type = 2 ; \ rcpp_output_condition = PROTECT(string_to_try_error("c++ exception (unknown reason)")) ; \ + ++nprot; \ } \ if( rcpp_output_type == 1 ){ \ Rf_onintr() ; \ } \ if( rcpp_output_type == 2 ){ \ - SEXP stop_sym = Rf_install( "stop" ) ; \ SEXP expr = PROTECT( Rf_lang2( stop_sym , rcpp_output_condition ) ) ; \ - Rf_eval( expr, R_GlobalEnv ) ; \ + ++nprot; \ + Rf_eval( expr, R_BaseEnv ) ; \ } \ if (rcpp_output_type == 3) { \ Rcpp::internal::resumeJump(rcpp_output_condition); \ - } + } \ + UNPROTECT(nprot); #endif #ifndef END_RCPP @@ -92,7 +117,9 @@ catch (...) { \ return string_to_try_error("c++ exception (unknown reason)"); \ } \ - return R_NilValue; + UNPROTECT(nprot); \ + return R_NilValue; \ + (void) stop_sym; /* never reached but suppresses warning */ #endif #define Rcpp_error(MESSAGE) throw Rcpp::exception(MESSAGE, __FILE__, __LINE__) 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.h b/inst/include/Rcpp/module/Module.h index 46e0e8c57..43edc20e0 100644 --- a/inst/include/Rcpp/module/Module.h +++ b/inst/include/Rcpp/module/Module.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- // // Module.h: Rcpp R/C++ interface class library -- Rcpp modules // -// Copyright (C) 2012 - 2013 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2020 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -51,7 +50,7 @@ namespace Rcpp { * @param args an array of R objects to use as arguments for the function * @param nargs number of arguments */ - inline SEXP invoke( const std::string& name_, SEXP* args, int nargs){ + inline SEXP invoke( const std::string& name_, SEXP* args, int nargs){ // #nocov start MAP::iterator it = functions.find( name_ ); if( it == functions.end() ){ throw std::range_error( "no such function" ) ; @@ -81,7 +80,7 @@ namespace Rcpp { } x.names() = names ; return x ; - } + } // #nocov end /** * vector of names of the functions @@ -117,7 +116,7 @@ namespace Rcpp { /** * completion information */ - CharacterVector complete(){ + CharacterVector complete(){ // #nocov start size_t nf = functions.size() ; size_t nc = classes.size() ; size_t n = nf + nc ; @@ -139,7 +138,7 @@ namespace Rcpp { res[i] = cit->first ; } return res ; - } + } // #nocov end /** * Returns a list that contains: @@ -199,13 +198,13 @@ namespace Rcpp { classes.insert( CLASS_PAIR( name_ , cptr ) ) ; } - inline bool has_function( const std::string& m){ + inline bool has_function( const std::string& m){ // #nocov start return functions.find(m) != functions.end() ; } inline bool has_class( const std::string& m){ return classes.find(m) != classes.end() ; - } + } // #nocov end CppClass get_class( const std::string& cl ) ; 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 c997bc2db..7ada6b65e 100644 --- a/inst/include/Rcpp/module/class.h +++ b/inst/include/Rcpp/module/class.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // 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. // @@ -111,8 +110,16 @@ return constructor( docstring, valid ) ; } -#include -#include + 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: @@ -123,8 +130,8 @@ SEXP newInstance( SEXP* args, int nargs ){ BEGIN_RCPP signed_constructor_class* p ; - int n = constructors.size() ; - for( int i=0; ivalid)(args, nargs) ; if( ok ){ @@ -135,7 +142,7 @@ signed_factory_class* pfact ; n = factories.size() ; - for( int i=0; ivalid)(args, nargs) ; if( ok ){ @@ -149,15 +156,15 @@ } bool has_default_constructor(){ - int n = constructors.size() ; + size_t n = constructors.size() ; signed_constructor_class* p ; - for( int i=0; inargs() == 0 ) return true ; } n = factories.size() ; signed_factory_class* pfact ; - for( int i=0; inargs() == 0 ) return true ; } @@ -167,12 +174,12 @@ SEXP invoke( SEXP method_xp, SEXP object, SEXP *args, int nargs ){ BEGIN_RCPP - vec_signed_method* mets = reinterpret_cast< vec_signed_method* >( EXTPTR_PTR( method_xp ) ) ; + vec_signed_method* mets = reinterpret_cast< vec_signed_method* >( R_ExternalPtrAddr( method_xp ) ) ; typename vec_signed_method::iterator it = mets->begin() ; - int n = mets->size() ; + size_t n = mets->size() ; method_class* m = 0 ; bool ok = false ; - for( int i=0; ivalid )( args, nargs) ){ m = (*it)->method ; ok = true ; @@ -194,12 +201,12 @@ SEXP invoke_void( SEXP method_xp, SEXP object, SEXP *args, int nargs ){ BEGIN_RCPP - vec_signed_method* mets = reinterpret_cast< vec_signed_method* >( EXTPTR_PTR( method_xp ) ) ; + vec_signed_method* mets = reinterpret_cast< vec_signed_method* >( R_ExternalPtrAddr( method_xp ) ) ; typename vec_signed_method::iterator it = mets->begin() ; - int n = mets->size() ; + size_t n = mets->size() ; method_class* m = 0 ; bool ok = false ; - for( int i=0; ivalid )( args, nargs) ){ m = (*it)->method ; ok = true ; @@ -216,12 +223,12 @@ SEXP invoke_notvoid( SEXP method_xp, SEXP object, SEXP *args, int nargs ){ BEGIN_RCPP - vec_signed_method* mets = reinterpret_cast< vec_signed_method* >( EXTPTR_PTR( method_xp ) ) ; + vec_signed_method* mets = reinterpret_cast< vec_signed_method* >( R_ExternalPtrAddr( method_xp ) ) ; typename vec_signed_method::iterator it = mets->begin() ; - int n = mets->size() ; + size_t n = mets->size() ; method_class* m = 0 ; bool ok = false ; - for( int i=0; ivalid )( args, nargs) ){ m = (*it)->method ; ok = true ; @@ -253,8 +260,42 @@ return *this ; } -#include -#include + 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() ; @@ -274,19 +315,19 @@ } Rcpp::CharacterVector method_names(){ - int n = 0 ; - int s = vec_methods.size() ; + size_t n = 0 ; + size_t s = vec_methods.size() ; typename map_vec_signed_method::iterator it = vec_methods.begin( ) ; - for( int i=0; isecond)->size() ; } Rcpp::CharacterVector out(n) ; it = vec_methods.begin() ; - int k = 0 ; - for( int i=0; isecond)->size() ; std::string name = it->first ; - for( int j=0; jsecond)->size() ; } Rcpp::CharacterVector mnames(n) ; Rcpp::IntegerVector res(n) ; it = vec_methods.begin() ; - int k = 0 ; - for( int i=0; isecond)->size() ; std::string name = it->first ; typename vec_signed_method::iterator m_it = (it->second)->begin() ; - for( int j=0; jnargs() ; } @@ -318,21 +359,21 @@ } Rcpp::LogicalVector methods_voidness(){ - int n = 0 ; - int s = vec_methods.size() ; + size_t n = 0 ; + size_t s = vec_methods.size() ; typename map_vec_signed_method::iterator it = vec_methods.begin( ) ; - for( int i=0; isecond)->size() ; } Rcpp::CharacterVector mnames(n) ; Rcpp::LogicalVector res(n) ; it = vec_methods.begin() ; - int k = 0 ; - for( int i=0; isecond)->size() ; std::string name = it->first ; typename vec_signed_method::iterator m_it = (it->second)->begin() ; - for( int j=0; jis_void() ; } @@ -343,21 +384,21 @@ Rcpp::CharacterVector property_names(){ - int n = properties.size() ; + size_t n = properties.size() ; Rcpp::CharacterVector out(n) ; typename PROPERTY_MAP::iterator it = properties.begin( ) ; - for( int i=0; ifirst ; } return out ; } Rcpp::List property_classes(){ - int n = properties.size() ; + size_t n = properties.size() ; Rcpp::CharacterVector pnames(n) ; Rcpp::List out(n) ; typename PROPERTY_MAP::iterator it = properties.begin( ) ; - for( int i=0; ifirst ; out[i] = it->second->get_class() ; } @@ -366,12 +407,12 @@ } Rcpp::CharacterVector complete(){ - int n = vec_methods.size() - specials ; - int ntotal = n + properties.size() ; + size_t n = vec_methods.size() - specials ; + size_t ntotal = n + properties.size() ; Rcpp::CharacterVector out(ntotal) ; typename map_vec_signed_method::iterator it = vec_methods.begin( ) ; std::string buffer ; - int i=0 ; + size_t i=0 ; for( ; ifirst ; if( buffer[0] == '[' ) continue ; @@ -393,25 +434,25 @@ SEXP getProperty( SEXP field_xp , SEXP object) { BEGIN_RCPP - prop_class* prop = reinterpret_cast< prop_class* >( EXTPTR_PTR( field_xp ) ) ; + prop_class* prop = reinterpret_cast< prop_class* >( R_ExternalPtrAddr( field_xp ) ) ; return prop->get( XP(object) ); END_RCPP } void setProperty( SEXP field_xp, SEXP object, SEXP value) { BEGIN_RCPP - prop_class* prop = reinterpret_cast< prop_class* >( EXTPTR_PTR( field_xp ) ) ; + prop_class* prop = reinterpret_cast< prop_class* >( R_ExternalPtrAddr( field_xp ) ) ; return prop->set( XP(object), value ); VOID_END_RCPP } Rcpp::List fields( const XP_Class& class_xp ){ - int n = properties.size() ; + size_t n = properties.size() ; Rcpp::CharacterVector pnames(n) ; Rcpp::List out(n) ; typename PROPERTY_MAP::iterator it = properties.begin( ) ; - for( int i=0; ifirst ; out[i] = S4_field( it->second, class_xp ) ; } @@ -424,12 +465,12 @@ #if RCPP_DEBUG_LEVEL > 0 Rf_PrintValue( class_xp ) ; #endif - int n = vec_methods.size() ; + size_t n = vec_methods.size() ; Rcpp::CharacterVector mnames(n) ; Rcpp::List res(n) ; typename map_vec_signed_method::iterator it = vec_methods.begin( ) ; vec_signed_method* v; - for( int i=0; ifirst ; v = it->second ; res[i] = S4_CppOverloadedMethods( v , class_xp, it->first.c_str(), buffer ) ; @@ -439,10 +480,10 @@ } Rcpp::List getConstructors( const XP_Class& class_xp, std::string& buffer){ - int n = constructors.size() ; + size_t n = constructors.size() ; Rcpp::List out(n) ; typename vec_signed_constructor::iterator it = constructors.begin( ) ; - for( int i=0; i( *it , class_xp, name, buffer ) ; } return out ; 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/print.h b/inst/include/Rcpp/print.h index 79a9430aa..d0d6560de 100644 --- a/inst/include/Rcpp/print.h +++ b/inst/include/Rcpp/print.h @@ -1,6 +1,5 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- // -// Copyright (C) 2015 - 2016 Dirk Eddelbuettel +// Copyright (C) 2015 - 2023 Dirk Eddelbuettel // // This file is part of Rcpp. // @@ -27,7 +26,7 @@ inline void print(SEXP s) { } inline void warningcall(SEXP call, const std::string & s) { - Rf_warningcall(call, s.c_str()); + Rf_warningcall(call, "%s", s.c_str()); } // also note that warning() is defined in file exceptions.h @@ -35,4 +34,3 @@ inline void warningcall(SEXP call, const std::string & s) { } #endif - diff --git a/inst/include/Rcpp/protection/Shelter.h b/inst/include/Rcpp/protection/Shelter.h index 93cb9aeb8..9ac43317b 100644 --- a/inst/include/Rcpp/protection/Shelter.h +++ b/inst/include/Rcpp/protection/Shelter.h @@ -23,25 +23,25 @@ namespace Rcpp { template class Shelter { public: - Shelter() : nprotected(0){} + Shelter() : nprotected(0) {} - inline SEXP operator()(SEXP x){ - nprotected++; - return Rcpp_protect(x) ; + inline SEXP operator()(SEXP x) { + if (x != R_NilValue) nprotected++; + return Rcpp_protect(x); } ~Shelter(){ - Rcpp_unprotect(nprotected) ; - nprotected = 0 ; + Rcpp_unprotect(nprotected); + nprotected = 0; } private: - int nprotected ; + int nprotected; // not defined on purpose Shelter(const Shelter&) ; Shelter& operator=(const Shelter&) ; - } ; + }; } #endif diff --git a/inst/include/Rcpp/proxy/AttributeProxy.h b/inst/include/Rcpp/proxy/AttributeProxy.h index 158a0e02e..1fbc40314 100644 --- a/inst/include/Rcpp/proxy/AttributeProxy.h +++ b/inst/include/Rcpp/proxy/AttributeProxy.h @@ -49,7 +49,7 @@ class AttributeProxyPolicy { return Rf_getAttrib( parent, attr_name ) ; } void set(SEXP x ){ - Rf_setAttrib( parent, attr_name, x ) ; + Rf_setAttrib( parent, attr_name, Shield(x) ) ; } } ; @@ -78,24 +78,27 @@ class AttributeProxyPolicy { } std::vector attributeNames() const { - std::vector v ; + std::vector v; +#if R_VERSION >= R_Version(4, 6, 0) + auto visitor = [](SEXP name, SEXP attr, void* data) -> SEXP { + std::vector* ptr = static_cast*>(data); + std::string s{CHAR(Rf_asChar(name))}; + ptr->push_back(s); + return NULL; + }; + R_mapAttrib(static_cast(*this).get__(), visitor, static_cast(&v)); +#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 { + return static_cast(*this).attr(attr) != R_NilValue; } diff --git a/inst/include/Rcpp/proxy/FieldProxy.h b/inst/include/Rcpp/proxy/FieldProxy.h index 768705188..f0a0fb50e 100644 --- a/inst/include/Rcpp/proxy/FieldProxy.h +++ b/inst/include/Rcpp/proxy/FieldProxy.h @@ -41,12 +41,14 @@ class FieldProxyPolicy { const std::string& field_name ; SEXP get() const { - Shield call( Rf_lang3( R_DollarSymbol, parent, Rf_mkString(field_name.c_str()) ) ) ; + Shield str(Rf_mkString(field_name.c_str())); + Shield call(Rf_lang3(R_DollarSymbol, parent, str)); return Rcpp_fast_eval( call, R_GlobalEnv ) ; } void set(SEXP x ) { SEXP dollarGetsSym = Rf_install( "$<-"); - Shield call( Rf_lang4( dollarGetsSym, parent, Rf_mkString(field_name.c_str()) , x ) ) ; + Shield str(Rf_mkString(field_name.c_str())); + Shield call(Rf_lang4(dollarGetsSym, parent, str, x)); parent.set__( Rcpp_fast_eval( call, R_GlobalEnv ) ); } } ; @@ -66,7 +68,8 @@ class FieldProxyPolicy { const std::string& field_name ; SEXP get() const { - Shield call( Rf_lang3( R_DollarSymbol, parent, Rf_mkString(field_name.c_str()) ) ) ; + Shield str(Rf_mkString(field_name.c_str())); + Shield call(Rf_lang3(R_DollarSymbol, parent, str)); return Rcpp_fast_eval( call, R_GlobalEnv ) ; } } ; diff --git a/inst/include/Rcpp/proxy/NamesProxy.h b/inst/include/Rcpp/proxy/NamesProxy.h index 78c68a692..b87b4b0bb 100644 --- a/inst/include/Rcpp/proxy/NamesProxy.h +++ b/inst/include/Rcpp/proxy/NamesProxy.h @@ -47,15 +47,17 @@ class NamesProxyPolicy{ } 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) ){ - SEXP y = parent.get__() ; - Rf_setAttrib( y, R_NamesSymbol, x ) ; + if( TYPEOF(x) == STRSXP && parent.size() == Rf_length(x) ){ // #nocov start + Rf_namesgets(parent, x); } else { /* use the slower and more flexible version (callback to R) */ SEXP namesSym = Rf_install( "names<-" ); - Shield new_vec(Rcpp_fast_eval(Rf_lang3(namesSym, parent, x), R_GlobalEnv)); - parent.set__(new_vec); + Shield call(Rf_lang3(namesSym, parent, x)); + Shield new_vec(Rcpp_fast_eval(call, R_GlobalEnv)); + parent.set__(new_vec); // #nocov end } } 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 new file mode 100644 index 000000000..720471b89 --- /dev/null +++ b/inst/include/Rcpp/r/compat.h @@ -0,0 +1,39 @@ + +// +// compat.h: Rcpp R/C++ interface class library -- compatibility defines +// +// Copyright (C) 2024 Dirk Eddelbuettel, 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_R_COMPAT_H +#define RCPP_R_COMPAT_H + +#include + +#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, 5, 0) +# define RCPP_VECTOR_PTR VECTOR_PTR_RO +#else +# define RCPP_VECTOR_PTR VECTOR_PTR +#endif + +#endif /* RCPP_R_COMPAT_H */ diff --git a/inst/include/Rcpp/r/headers.h b/inst/include/Rcpp/r/headers.h index 950c8a168..7bf972a3c 100644 --- a/inst/include/Rcpp/r/headers.h +++ b/inst/include/Rcpp/r/headers.h @@ -1,7 +1,8 @@ // headers.h: Rcpp R/C++ interface class library -- R headers // // Copyright (C) 2008 - 2009 Dirk Eddelbuettel -// Copyright (C) 2009 - 2013 Dirk Eddelbuettel and Romain Francois +// 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. // @@ -22,13 +23,13 @@ #define RCPP__R__HEADERS__H // include R headers, but set R_NO_REMAP and access everything via Rf_ prefixes -#define MAXELTSIZE 8192 -#define R_NO_REMAP - -// until September 2019, define RCPP_NO_STRICT_R_HEADERS for transition -#ifndef RCPP_NO_STRICT_R_HEADERS -# define RCPP_NO_STRICT_R_HEADERS +#ifndef MAXELTSIZE + #define MAXELTSIZE 8192 +#endif +#ifndef R_NO_REMAP + #define R_NO_REMAP #endif + // define strict headers for R to not clash on ERROR, MESSGAGE, etc #ifndef RCPP_NO_STRICT_R_HEADERS # ifndef STRICT_R_HEADERS @@ -36,6 +37,13 @@ # endif #endif +// no rtti implies no modules +#ifdef RCPP_NO_RTTI +# ifndef RCPP_NO_MODULES +# define RCPP_NO_MODULES +# endif +#endif + // prevent some macro pollution when including R headers // in particular, on Linux, gcc 'leaks' the 'major', // 'minor' and 'makedev' macros on Linux; we prevent @@ -65,6 +73,7 @@ #include #include #include +#include #include /* Ensure NORET defined (normally provided by R headers with R >= 3.2.0) */ @@ -92,8 +101,4 @@ # pragma pop_macro("makedev") #endif -#if (defined(RCPP_USE_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 e95b65ee5..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. // @@ -31,7 +30,8 @@ namespace Rcpp { Armor res; try{ SEXP funSym = Rf_install(fun); - res = Rcpp_fast_eval(Rf_lang2(funSym, x), R_GlobalEnv); + Shield call(Rf_lang2(funSym, x)); + res = Rcpp_fast_eval(call, R_GlobalEnv); } catch( eval_error& e) { const char* fmt = "Could not convert using R function: %s."; throw not_compatible(fmt, fun); @@ -142,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" ); } } @@ -160,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 { @@ -172,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/routines.h b/inst/include/Rcpp/routines.h index 437e42aee..d83573000 100644 --- a/inst/include/Rcpp/routines.h +++ b/inst/include/Rcpp/routines.h @@ -1,7 +1,9 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- + +// routines.h: Rcpp R/C++ interface class library -- callable function setup // -// Copyright (C) 2013 Romain Francois -// Copyright (C) 2015 Dirk Eddelbuettel +// Copyright (C) 2013 - 2014 Romain Francois +// Copyright (C) 2015 - 2020 Romain Francois and Dirk Eddelbuettel +// Copyright (C) 2021 Romain Francois, Dirk Eddelbuettel and Iñaki Ucar // // This file is part of Rcpp. // @@ -21,6 +23,8 @@ #ifndef RCPP_ROUTINE_H #define RCPP_ROUTINE_H +#include + #if defined(COMPILING_RCPP) // the idea is that this file should be generated automatically by Rcpp::register @@ -38,6 +42,14 @@ namespace Rcpp{ } double mktime00(struct tm &); struct tm * gmtime_(const time_t * const); + + void Rcpp_precious_init(); + void Rcpp_precious_teardown(); + SEXP Rcpp_precious_preserve(SEXP object); + void Rcpp_precious_remove(SEXP token); + + Rostream& Rcpp_cout_get(); + Rostream& Rcpp_cerr_get(); } SEXP rcpp_get_stack_trace(); @@ -127,6 +139,38 @@ namespace Rcpp { return fun(x); } + inline attribute_hidden void Rcpp_precious_init() { + typedef void (*Fun)(void); + static Fun fun = GET_CALLABLE("Rcpp_precious_init"); + fun(); + } + inline attribute_hidden void Rcpp_precious_teardown() { + typedef void (*Fun)(void); + static Fun fun = GET_CALLABLE("Rcpp_precious_teardown"); + fun(); + } + inline attribute_hidden SEXP Rcpp_precious_preserve(SEXP object) { + typedef SEXP (*Fun)(SEXP); + static Fun fun = GET_CALLABLE("Rcpp_precious_preserve"); + return fun(object); + } + inline attribute_hidden void Rcpp_precious_remove(SEXP token) { + typedef void (*Fun)(SEXP); + static Fun fun = GET_CALLABLE("Rcpp_precious_remove"); + fun(token); + } + + inline attribute_hidden Rostream& Rcpp_cout_get() { + typedef Rostream& (*Fun)(); + static Fun fun = GET_CALLABLE("Rcpp_cout_get"); + return fun(); + } + inline attribute_hidden Rostream& Rcpp_cerr_get() { + typedef Rostream& (*Fun)(); + static Fun fun = GET_CALLABLE("Rcpp_cerr_get"); + return fun(); + } + } // The 'attribute_hidden' used here is a simple precessor defined from diff --git a/inst/include/Rcpp/storage/PreserveStorage.h b/inst/include/Rcpp/storage/PreserveStorage.h index be8d0fdab..84e41dc77 100644 --- a/inst/include/Rcpp/storage/PreserveStorage.h +++ b/inst/include/Rcpp/storage/PreserveStorage.h @@ -1,3 +1,24 @@ + +// PreserveStorage.h: Rcpp R/C++ interface class library -- helper class +// +// Copyright (C) 2013 - 2020 Romain Francois +// Copyright (C) 2021 Romain Francois and 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_PreserveStorage_h #define Rcpp_PreserveStorage_h @@ -7,15 +28,20 @@ namespace Rcpp{ class PreserveStorage { public: - PreserveStorage() : data(R_NilValue){} + PreserveStorage() : data(R_NilValue), token(R_NilValue){} ~PreserveStorage(){ - Rcpp_ReleaseObject(data) ; + Rcpp_PreciousRelease(token) ; data = R_NilValue; + token = R_NilValue; } inline void set__(SEXP x){ - data = Rcpp_ReplaceObject(data, x) ; + if (data != x) { + data = x; + Rcpp_PreciousRelease(token); + token = Rcpp_PreciousPreserve(data); + } // calls the update method of CLASS // this is where to react to changes in the underlying SEXP @@ -28,7 +54,9 @@ namespace Rcpp{ inline SEXP invalidate__(){ SEXP out = data ; + Rcpp_PreciousRelease(token); data = R_NilValue ; + token = R_NilValue ; return out ; } @@ -48,6 +76,7 @@ namespace Rcpp{ private: SEXP data ; + SEXP token ; } ; } diff --git a/inst/include/Rcpp/sugar/functions/cbind.h b/inst/include/Rcpp/sugar/functions/cbind.h index c5bdceac1..84e5bfe4b 100644 --- a/inst/include/Rcpp/sugar/functions/cbind.h +++ b/inst/include/Rcpp/sugar/functions/cbind.h @@ -1,830 +1,830 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// -// cbind.h: Rcpp R/C++ interface class library -- cbind -// -// Copyright (C) 2016 Nathan Russell -// -// 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__cbind_h -#define Rcpp__sugar__cbind_h - -namespace Rcpp { -namespace sugar { -namespace cbind_impl { - -// override r_sexptype_traits for STRSXP -template -struct cbind_sexptype_traits - : public Rcpp::traits::r_sexptype_traits {}; - -template <> -struct cbind_sexptype_traits { - enum { rtype = STRSXP }; -}; - -// override storage_type (int) -template -struct cbind_storage_type - : public Rcpp::traits::storage_type {}; - -template <> -struct cbind_storage_type { - typedef bool type; -}; - - -// CRTP base -template -class BindableExpression { -public: - typedef typename cbind_storage_type::type stored_type; - - inline stored_type operator[](R_xlen_t i) const { - return static_cast(*this)[i]; - } - - inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { - return static_cast(*this)(i, j); - } - - inline R_xlen_t size() const { - return static_cast(*this).size(); - } - - inline R_xlen_t nrow() const { - return static_cast(*this).nrow(); - } - - inline R_xlen_t ncol() const { - return static_cast(*this).ncol(); - } - - operator E&() { return static_cast(*this); } - operator const E&() const { return static_cast(*this); } -}; - -// Matrix, Vector interface to BindableExpression -template -class ContainerBindable - : public BindableExpression > { -public: - typedef typename cbind_storage_type::type stored_type; - -private: - T vec; - R_xlen_t len, nr, nc; - -public: - ContainerBindable(const Rcpp::Matrix& vec_) - : vec(vec_), len(vec.ncol() * vec.nrow()), - nr(vec.nrow()), nc(vec.ncol()) - {} - - ContainerBindable(const Rcpp::Vector& vec_) - : vec(vec_), len(vec.size()), - nr(vec.size()), nc(1) - {} - - template - ContainerBindable(const BindableExpression& e) - : vec(e.size()), len(e.size()), - nr(e.nrow()), nc(e.ncol()) - { - for (R_xlen_t i = 0; i < len; i++) { - vec[i] = e[i]; - } - } - - inline R_xlen_t size() const { return len; } - - inline R_xlen_t nrow() const { return nr; } - - inline R_xlen_t ncol() const { return nc; } - - inline stored_type operator[](R_xlen_t i) const { - return vec[i]; - } - - inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { - return vec[i + nr * j]; - } -}; - - -template -struct scalar { - typedef typename cbind_storage_type::type type; -}; - -// scalar interface to BindableExpression -template -class ScalarBindable - : public BindableExpression< - cbind_sexptype_traits::rtype, ScalarBindable > { -public: - typedef T stored_type; - enum { RTYPE = cbind_sexptype_traits::rtype }; - -private: - T t; - -public: - ScalarBindable(const T& t_) : t(t_) {} - - inline R_xlen_t size() const { return 1; } - - inline R_xlen_t nrow() const { return 1; } - - inline R_xlen_t ncol() const { return 1; } - - inline stored_type operator[](R_xlen_t i) const { - return t; - } - - inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { - return t; - } -}; - - -// binding logic; non-scalar operands -template -class JoinOp - : public BindableExpression >, - public Rcpp::MatrixBase > { -public: - typedef typename cbind_storage_type::type stored_type; - -private: - const E1& e1; - const E2& e2; - -public: - JoinOp(const BindableExpression& e1_, - const BindableExpression& e2_) - : e1(e1_), e2(e2_) - { - if (e1.nrow() != e2.nrow()) { - std::string msg = - "Error in cbind: " - "Matrix and Vector operands " - "must have equal " - "number of rows (length)."; - Rcpp::stop(msg); - } - } - - inline R_xlen_t size() const { return e1.size() + e2.size(); } - - inline R_xlen_t nrow() const { return e1.nrow(); } - - inline R_xlen_t ncol() const { return e1.ncol() + e2.ncol(); } - - inline stored_type operator[](R_xlen_t i) const { - return (i < e1.size()) ? e1[i] : e2[i - e1.size()]; - } - - inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { - R_xlen_t index = i + nrow() * j; - return (*this)[index]; - } -}; - -// binding logic; rhs scalar -template -class JoinOp::type> > - : public BindableExpression::type> > >, - public Rcpp::MatrixBase::type> > > { -public: - typedef typename cbind_storage_type::type stored_type; - typedef ScalarBindable::type> E2; - -private: - const E1& e1; - const E2& e2; - -public: - JoinOp(const BindableExpression& e1_, - const BindableExpression& e2_) - : e1(e1_), e2(e2_) - {} - - inline R_xlen_t size() const { return e1.size() + e1.nrow(); } - - inline R_xlen_t nrow() const { return e1.nrow(); } - - inline R_xlen_t ncol() const { return e1.ncol() + 1; } - - inline stored_type operator[](R_xlen_t i) const { - return (i < e1.size()) ? e1[i] : e2[i]; - } - - inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { - R_xlen_t index = i + nrow() * j; - return (*this)[index]; - } -}; - -// binding logic; lhs scalar -template -class JoinOp::type>, E2> - : public BindableExpression::type>, E2> >, - public Rcpp::MatrixBase::type>, E2> > { -public: - typedef typename cbind_storage_type::type stored_type; - typedef ScalarBindable::type> E1; - -private: - const E1& e1; - const E2& e2; - -public: - JoinOp(const BindableExpression& e1_, - const BindableExpression& e2_) - : e1(e1_), e2(e2_) - {} - - inline R_xlen_t size() const { return e2.size() + e2.nrow(); } - - inline R_xlen_t nrow() const { return e2.nrow(); } - - inline R_xlen_t ncol() const { return e2.ncol() + 1; } - - inline stored_type operator[](R_xlen_t i) const { - return (i < e2.nrow()) ? e1[i] : e2[i - e2.nrow()]; - } - - inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { - R_xlen_t index = i + nrow() * j; - return (*this)[index]; - } -}; - -// binding logic; both scalar -template -class JoinOp::type>, - ScalarBindable::type> > - : public BindableExpression::type>, - ScalarBindable::type> > >, - public Rcpp::MatrixBase::type>, - ScalarBindable::type> > > { -public: - typedef typename cbind_storage_type::type stored_type; - typedef ScalarBindable::type> E1; - typedef ScalarBindable::type> E2; - -private: - const E1& e1; - const E2& e2; - -public: - JoinOp(const BindableExpression& e1_, - const BindableExpression& e2_) - : e1(e1_), e2(e2_) - {} - - inline R_xlen_t size() const { return e2.size() + e2.nrow(); } - - inline R_xlen_t nrow() const { return e2.nrow(); } - - inline R_xlen_t ncol() const { return e2.ncol() + 1; } - - inline stored_type operator[](R_xlen_t i) const { - return (i < e2.nrow()) ? e1[i] : e2[i]; - } - - inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { - R_xlen_t index = i + nrow() * j; - return (*this)[index]; - } -}; - -// for template argument deduction -template -inline ContainerBindable > -MakeContainerBindable(const Rcpp::Matrix& x) { - return ContainerBindable >(x); -} - -template -inline ContainerBindable > -MakeContainerBindable(const Rcpp::Vector& x) { - return ContainerBindable >(x); -} - -template <> -inline ContainerBindable > -MakeContainerBindable(const Rcpp::Matrix& x) { - return ContainerBindable >(x); -} - -template <> -inline ContainerBindable > -MakeContainerBindable(const Rcpp::Vector& x) { - return ContainerBindable >(x); -} - -template -inline ScalarBindable -MakeScalarBindable(const T& t) { - return ScalarBindable(t); -} - -// for expressions of arbitrary length -template -inline JoinOp operator,( - const BindableExpression& e1, - const BindableExpression& e2) -{ - return JoinOp(e1, e2); -} - -// helpers -namespace detail { - -// distinguish Matrix/Vector from scalar -template -class has_stored_type { -private: - typedef char yes; - typedef struct { - char array[2]; - } no; - - template - static yes test(typename C::stored_type*); - - template - static no test(...); - -public: - static const bool value = sizeof(test(0)) == sizeof(yes); -}; - -// functor to dispatch appropriate Make*Bindable() call -template ::value> -struct MakeBindableCall {}; - -template -struct MakeBindableCall { - typedef typename cbind_storage_type< - cbind_sexptype_traits::rtype - >::type stored_type; - - enum { RTYPE = cbind_sexptype_traits::rtype }; - - ContainerBindable operator()(const T& t) const { - return MakeContainerBindable(t); - } -}; - -// specialize for LGLSXP -template <> -struct MakeBindableCall, true> { - typedef Rcpp::Matrix T; - typedef bool stored_type; - - enum { RTYPE = cbind_sexptype_traits::rtype }; - - ContainerBindable operator()(const T& t) const { - return MakeContainerBindable(t); - } -}; - -template <> -struct MakeBindableCall, true> { - typedef Rcpp::Vector T; - typedef bool stored_type; - - enum { RTYPE = cbind_sexptype_traits::rtype }; - - ContainerBindable operator()(const T& t) const { - return MakeContainerBindable(t); - } -}; - -template -struct MakeBindableCall { - enum { RTYPE = cbind_sexptype_traits::rtype }; - - ScalarBindable operator()(const T& t) const { - return MakeScalarBindable(t); - } -}; - -template -inline typename Rcpp::traits::enable_if< - has_stored_type::value, - MakeBindableCall ->::type -MakeBindable(const T& t) { - return MakeBindableCall(); -} - -template -inline typename Rcpp::traits::enable_if< - !has_stored_type::value, - MakeBindableCall ->::type -MakeBindable(const T& t) { - return MakeBindableCall(); -} - - -// determine cbind return type from first template -// parameter, agnostic of Matrix/Vector/scalar -template ::value> -struct matrix_return {}; - -template -struct matrix_return { - typedef typename cbind_storage_type< - cbind_sexptype_traits::rtype - >::type stored_type; - - enum { RTYPE = cbind_sexptype_traits::rtype }; - typedef Rcpp::Matrix type; -}; - -// specialize for LGLSXP -// normally would default to IntegerMatrix -template <> -struct matrix_return, true> { - typedef Rcpp::Matrix type; -}; - -template <> -struct matrix_return, true> { - typedef Rcpp::Matrix type; -}; - -template <> -struct matrix_return { - typedef Rcpp::Matrix type; -}; - -template -struct matrix_return { - enum { RTYPE = cbind_sexptype_traits::rtype }; - typedef Rcpp::Matrix type; -}; - -} // detail - -template ::value> -struct matrix_return - : public detail::matrix_return {}; - -template -struct matrix_return - : public detail::matrix_return {}; - -} // cbind_impl - -#define MakeBindable(x) (cbind_impl::detail::MakeBindable(x)(x)) - -// begin cbind overloads - -template -inline typename cbind_impl::matrix_return::type -cbind(const T1& t1, const T2& t2) { - return (MakeBindable(t1), MakeBindable(t2)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(const T1& t1, const T2& t2, const T3& t3) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4)); -} - -// 5 -template -inline typename cbind_impl::matrix_return::type -cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9)); -} - -// 10 -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14)); -} - -// 15 -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19)); -} - -// 20 -template -inline typename cbind_impl::matrix_return::type -cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24)); -} - -// 25 -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29)); -} - -// 30 -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34)); -} - -// 35 -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39)); -} - -// 40 -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44)); -} - -// 45 -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47, const T48& t48) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47), MakeBindable(t48)); -} - -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47, const T48& t48, const T49& t49) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47), MakeBindable(t48), MakeBindable(t49)); -} - -// 50 -template -inline typename cbind_impl::matrix_return::type -cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47, const T48& t48, const T49& t49, const T50& t50) { - return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47), MakeBindable(t48), MakeBindable(t49), MakeBindable(t50)); -} - -// end cbind overloads - -#undef MakeBindable - -} // sugar - -namespace { -using sugar::cbind; -} - -} // Rcpp - -#endif // Rcpp__sugar__cbind_h +// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- +// +// cbind.h: Rcpp R/C++ interface class library -- cbind +// +// Copyright (C) 2016 Nathan Russell +// +// 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__cbind_h +#define Rcpp__sugar__cbind_h + +namespace Rcpp { +namespace sugar { +namespace cbind_impl { + +// override r_sexptype_traits for STRSXP +template +struct cbind_sexptype_traits + : public Rcpp::traits::r_sexptype_traits {}; + +template <> +struct cbind_sexptype_traits { + enum { rtype = STRSXP }; +}; + +// override storage_type (int) +template +struct cbind_storage_type + : public Rcpp::traits::storage_type {}; + +template <> +struct cbind_storage_type { + typedef bool type; +}; + + +// CRTP base +template +class BindableExpression { +public: + typedef typename cbind_storage_type::type stored_type; + + inline stored_type operator[](R_xlen_t i) const { + return static_cast(*this)[i]; + } + + inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { + return static_cast(*this)(i, j); + } + + inline R_xlen_t size() const { + return static_cast(*this).size(); + } + + inline R_xlen_t nrow() const { + return static_cast(*this).nrow(); + } + + inline R_xlen_t ncol() const { + return static_cast(*this).ncol(); + } + + operator E&() { return static_cast(*this); } + operator const E&() const { return static_cast(*this); } +}; + +// Matrix, Vector interface to BindableExpression +template +class ContainerBindable + : public BindableExpression > { +public: + typedef typename cbind_storage_type::type stored_type; + +private: + T vec; + R_xlen_t len, nr, nc; + +public: + ContainerBindable(const Rcpp::Matrix& vec_) + : vec(vec_), len(vec.ncol() * vec.nrow()), + nr(vec.nrow()), nc(vec.ncol()) + {} + + ContainerBindable(const Rcpp::Vector& vec_) + : vec(vec_), len(vec.size()), + nr(vec.size()), nc(1) + {} + + template + ContainerBindable(const BindableExpression& e) + : vec(e.size()), len(e.size()), + nr(e.nrow()), nc(e.ncol()) + { + for (R_xlen_t i = 0; i < len; i++) { + vec[i] = e[i]; + } + } + + inline R_xlen_t size() const { return len; } + + inline R_xlen_t nrow() const { return nr; } + + inline R_xlen_t ncol() const { return nc; } + + inline stored_type operator[](R_xlen_t i) const { + return vec[i]; + } + + inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { + return vec[i + nr * j]; + } +}; + + +template +struct scalar { + typedef typename cbind_storage_type::type type; +}; + +// scalar interface to BindableExpression +template +class ScalarBindable + : public BindableExpression< + cbind_sexptype_traits::rtype, ScalarBindable > { +public: + typedef T stored_type; + enum { RTYPE = cbind_sexptype_traits::rtype }; + +private: + T t; + +public: + ScalarBindable(const T& t_) : t(t_) {} + + inline R_xlen_t size() const { return 1; } + + inline R_xlen_t nrow() const { return 1; } + + inline R_xlen_t ncol() const { return 1; } + + inline stored_type operator[](R_xlen_t i) const { + return t; + } + + inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { + return t; + } +}; + + +// binding logic; non-scalar operands +template +class JoinOp + : public BindableExpression >, + public Rcpp::MatrixBase > { +public: + typedef typename cbind_storage_type::type stored_type; + +private: + const E1& e1; + const E2& e2; + +public: + JoinOp(const BindableExpression& e1_, + const BindableExpression& e2_) + : e1(e1_), e2(e2_) + { + if (e1.nrow() != e2.nrow()) { + std::string msg = + "Error in cbind: " + "Matrix and Vector operands " + "must have equal " + "number of rows (length)."; + Rcpp::stop(msg); + } + } + + inline R_xlen_t size() const { return e1.size() + e2.size(); } + + inline R_xlen_t nrow() const { return e1.nrow(); } + + inline R_xlen_t ncol() const { return e1.ncol() + e2.ncol(); } + + inline stored_type operator[](R_xlen_t i) const { + return (i < e1.size()) ? e1[i] : e2[i - e1.size()]; + } + + inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { + R_xlen_t index = i + nrow() * j; + return (*this)[index]; + } +}; + +// binding logic; rhs scalar +template +class JoinOp::type> > + : public BindableExpression::type> > >, + public Rcpp::MatrixBase::type> > > { +public: + typedef typename cbind_storage_type::type stored_type; + typedef ScalarBindable::type> E2; + +private: + const E1& e1; + const E2& e2; + +public: + JoinOp(const BindableExpression& e1_, + const BindableExpression& e2_) + : e1(e1_), e2(e2_) + {} + + inline R_xlen_t size() const { return e1.size() + e1.nrow(); } + + inline R_xlen_t nrow() const { return e1.nrow(); } + + inline R_xlen_t ncol() const { return e1.ncol() + 1; } + + inline stored_type operator[](R_xlen_t i) const { + return (i < e1.size()) ? e1[i] : e2[i]; + } + + inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { + R_xlen_t index = i + nrow() * j; + return (*this)[index]; + } +}; + +// binding logic; lhs scalar +template +class JoinOp::type>, E2> + : public BindableExpression::type>, E2> >, + public Rcpp::MatrixBase::type>, E2> > { +public: + typedef typename cbind_storage_type::type stored_type; + typedef ScalarBindable::type> E1; + +private: + const E1& e1; + const E2& e2; + +public: + JoinOp(const BindableExpression& e1_, + const BindableExpression& e2_) + : e1(e1_), e2(e2_) + {} + + inline R_xlen_t size() const { return e2.size() + e2.nrow(); } + + inline R_xlen_t nrow() const { return e2.nrow(); } + + inline R_xlen_t ncol() const { return e2.ncol() + 1; } + + inline stored_type operator[](R_xlen_t i) const { + return (i < e2.nrow()) ? e1[i] : e2[i - e2.nrow()]; + } + + inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { + R_xlen_t index = i + nrow() * j; + return (*this)[index]; + } +}; + +// binding logic; both scalar +template +class JoinOp::type>, + ScalarBindable::type> > + : public BindableExpression::type>, + ScalarBindable::type> > >, + public Rcpp::MatrixBase::type>, + ScalarBindable::type> > > { +public: + typedef typename cbind_storage_type::type stored_type; + typedef ScalarBindable::type> E1; + typedef ScalarBindable::type> E2; + +private: + const E1& e1; + const E2& e2; + +public: + JoinOp(const BindableExpression& e1_, + const BindableExpression& e2_) + : e1(e1_), e2(e2_) + {} + + inline R_xlen_t size() const { return e2.size() + e2.nrow(); } + + inline R_xlen_t nrow() const { return e2.nrow(); } + + inline R_xlen_t ncol() const { return e2.ncol() + 1; } + + inline stored_type operator[](R_xlen_t i) const { + return (i < e2.nrow()) ? e1[i] : e2[i]; + } + + inline stored_type operator()(R_xlen_t i, R_xlen_t j) const { + R_xlen_t index = i + nrow() * j; + return (*this)[index]; + } +}; + +// for template argument deduction +template +inline ContainerBindable > +MakeContainerBindable(const Rcpp::Matrix& x) { + return ContainerBindable >(x); +} + +template +inline ContainerBindable > +MakeContainerBindable(const Rcpp::Vector& x) { + return ContainerBindable >(x); +} + +template <> +inline ContainerBindable > +MakeContainerBindable(const Rcpp::Matrix& x) { + return ContainerBindable >(x); +} + +template <> +inline ContainerBindable > +MakeContainerBindable(const Rcpp::Vector& x) { + return ContainerBindable >(x); +} + +template +inline ScalarBindable +MakeScalarBindable(const T& t) { + return ScalarBindable(t); +} + +// for expressions of arbitrary length +template +inline JoinOp operator,( + const BindableExpression& e1, + const BindableExpression& e2) +{ + return JoinOp(e1, e2); +} + +// helpers +namespace detail { + +// distinguish Matrix/Vector from scalar +template +class has_stored_type { +private: + typedef char yes; + typedef struct { + char array[2]; + } no; + + template + static yes test(typename C::stored_type*); + + template + static no test(...); + +public: + static const bool value = sizeof(test(0)) == sizeof(yes); +}; + +// functor to dispatch appropriate Make*Bindable() call +template ::value> +struct MakeBindableCall {}; + +template +struct MakeBindableCall { + typedef typename cbind_storage_type< + cbind_sexptype_traits::rtype + >::type stored_type; + + enum { RTYPE = cbind_sexptype_traits::rtype }; + + ContainerBindable operator()(const T& t) const { + return MakeContainerBindable(t); + } +}; + +// specialize for LGLSXP +template <> +struct MakeBindableCall, true> { + typedef Rcpp::Matrix T; + typedef bool stored_type; + + enum { RTYPE = cbind_sexptype_traits::rtype }; + + ContainerBindable operator()(const T& t) const { + return MakeContainerBindable(t); + } +}; + +template <> +struct MakeBindableCall, true> { + typedef Rcpp::Vector T; + typedef bool stored_type; + + enum { RTYPE = cbind_sexptype_traits::rtype }; + + ContainerBindable operator()(const T& t) const { + return MakeContainerBindable(t); + } +}; + +template +struct MakeBindableCall { + enum { RTYPE = cbind_sexptype_traits::rtype }; + + ScalarBindable operator()(const T& t) const { + return MakeScalarBindable(t); + } +}; + +template +inline typename Rcpp::traits::enable_if< + has_stored_type::value, + MakeBindableCall +>::type +MakeBindable(const T& t) { + return MakeBindableCall(); +} + +template +inline typename Rcpp::traits::enable_if< + !has_stored_type::value, + MakeBindableCall +>::type +MakeBindable(const T& t) { + return MakeBindableCall(); +} + + +// determine cbind return type from first template +// parameter, agnostic of Matrix/Vector/scalar +template ::value> +struct matrix_return {}; + +template +struct matrix_return { + typedef typename cbind_storage_type< + cbind_sexptype_traits::rtype + >::type stored_type; + + enum { RTYPE = cbind_sexptype_traits::rtype }; + typedef Rcpp::Matrix type; +}; + +// specialize for LGLSXP +// normally would default to IntegerMatrix +template <> +struct matrix_return, true> { + typedef Rcpp::Matrix type; +}; + +template <> +struct matrix_return, true> { + typedef Rcpp::Matrix type; +}; + +template <> +struct matrix_return { + typedef Rcpp::Matrix type; +}; + +template +struct matrix_return { + enum { RTYPE = cbind_sexptype_traits::rtype }; + typedef Rcpp::Matrix type; +}; + +} // detail + +template ::value> +struct matrix_return + : public detail::matrix_return {}; + +template +struct matrix_return + : public detail::matrix_return {}; + +} // cbind_impl + +#define MakeBindable(x) (cbind_impl::detail::MakeBindable(x)(x)) + +// begin cbind overloads + +template +inline typename cbind_impl::matrix_return::type +cbind(const T1& t1, const T2& t2) { + return (MakeBindable(t1), MakeBindable(t2)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(const T1& t1, const T2& t2, const T3& t3) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4)); +} + +// 5 +template +inline typename cbind_impl::matrix_return::type +cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9)); +} + +// 10 +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14)); +} + +// 15 +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19)); +} + +// 20 +template +inline typename cbind_impl::matrix_return::type +cbind(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 (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24)); +} + +// 25 +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29)); +} + +// 30 +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34)); +} + +// 35 +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39)); +} + +// 40 +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44)); +} + +// 45 +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47, const T48& t48) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47), MakeBindable(t48)); +} + +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47, const T48& t48, const T49& t49) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47), MakeBindable(t48), MakeBindable(t49)); +} + +// 50 +template +inline typename cbind_impl::matrix_return::type +cbind(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 T21& t21, const T22& t22, const T23& t23, const T24& t24, const T25& t25, const T26& t26, const T27& t27, const T28& t28, const T29& t29, const T30& t30, const T31& t31, const T32& t32, const T33& t33, const T34& t34, const T35& t35, const T36& t36, const T37& t37, const T38& t38, const T39& t39, const T40& t40, const T41& t41, const T42& t42, const T43& t43, const T44& t44, const T45& t45, const T46& t46, const T47& t47, const T48& t48, const T49& t49, const T50& t50) { + return (MakeBindable(t1), MakeBindable(t2), MakeBindable(t3), MakeBindable(t4), MakeBindable(t5), MakeBindable(t6), MakeBindable(t7), MakeBindable(t8), MakeBindable(t9), MakeBindable(t10), MakeBindable(t11), MakeBindable(t12), MakeBindable(t13), MakeBindable(t14), MakeBindable(t15), MakeBindable(t16), MakeBindable(t17), MakeBindable(t18), MakeBindable(t19), MakeBindable(t20), MakeBindable(t21), MakeBindable(t22), MakeBindable(t23), MakeBindable(t24), MakeBindable(t25), MakeBindable(t26), MakeBindable(t27), MakeBindable(t28), MakeBindable(t29), MakeBindable(t30), MakeBindable(t31), MakeBindable(t32), MakeBindable(t33), MakeBindable(t34), MakeBindable(t35), MakeBindable(t36), MakeBindable(t37), MakeBindable(t38), MakeBindable(t39), MakeBindable(t40), MakeBindable(t41), MakeBindable(t42), MakeBindable(t43), MakeBindable(t44), MakeBindable(t45), MakeBindable(t46), MakeBindable(t47), MakeBindable(t48), MakeBindable(t49), MakeBindable(t50)); +} + +// end cbind overloads + +#undef MakeBindable + +} // sugar + +namespace { +using sugar::cbind; +} + +} // Rcpp + +#endif // Rcpp__sugar__cbind_h diff --git a/inst/include/Rcpp/sugar/functions/lapply.h b/inst/include/Rcpp/sugar/functions/lapply.h index 5856d11cc..7d098010e 100644 --- a/inst/include/Rcpp/sugar/functions/lapply.h +++ b/inst/include/Rcpp/sugar/functions/lapply.h @@ -2,7 +2,8 @@ // // lapply.h: Rcpp R/C++ interface class library -- lapply // -// 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. // @@ -33,7 +34,7 @@ class Lapply : public VectorBase< > { 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/mean.h b/inst/include/Rcpp/sugar/functions/mean.h index c5e16c6b7..1ffde0d37 100644 --- a/inst/include/Rcpp/sugar/functions/mean.h +++ b/inst/include/Rcpp/sugar/functions/mean.h @@ -1,8 +1,6 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// // mean.h: Rcpp R/C++ interface class library -- mean // -// Copyright (C) 2011 - 2015 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2011 - 2023 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -80,8 +78,8 @@ class Mean : public Lazy > { si += ti/n; } Rcomplex z; - z.r = s; - z.i = si; + z.r = static_cast(s); + z.i = static_cast(si); return z; } private: @@ -158,5 +156,3 @@ inline sugar::Mean mean(const VectorBase& t) { } // Rcpp #endif - - diff --git a/inst/include/Rcpp/sugar/functions/sample.h b/inst/include/Rcpp/sugar/functions/sample.h index 9f4817b1c..50bd63813 100644 --- a/inst/include/Rcpp/sugar/functions/sample.h +++ b/inst/include/Rcpp/sugar/functions/sample.h @@ -348,7 +348,7 @@ inline Vector EmpiricalSample(int n, int size, bool replace, bool one_ba return ans; } - int* x = reinterpret_cast(R_alloc(n, sizeof(int))); + IntegerVector x = no_init(n); for (int i = 0; i < n; i++) { x[i] = i; } @@ -378,7 +378,7 @@ inline Vector EmpiricalSample(int size, bool replace, const Vector return ans; } - int* x = reinterpret_cast(R_alloc(n, sizeof(int))); + IntegerVector x = no_init(n); for (int i = 0; i < n; i++) { x[i] = i; } diff --git a/inst/include/Rcpp/sugar/functions/sapply.h b/inst/include/Rcpp/sugar/functions/sapply.h index 2ade4063e..5b1311c5e 100644 --- a/inst/include/Rcpp/sugar/functions/sapply.h +++ b/inst/include/Rcpp/sugar/functions/sapply.h @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // sapply.h: Rcpp R/C++ interface class library -- sapply // -// 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. // @@ -22,36 +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) - typedef typename ::std::result_of::type type; -#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 ; @@ -82,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 ; @@ -119,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/table.h b/inst/include/Rcpp/sugar/functions/table.h index 2cd647ca5..bc3d8074a 100644 --- a/inst/include/Rcpp/sugar/functions/table.h +++ b/inst/include/Rcpp/sugar/functions/table.h @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// // table.h: Rcpp R/C++ interface class library -- table match // -// 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. // @@ -55,36 +54,6 @@ class Grabber{ R_xlen_t index ; } ; -// we define a different Table class depending on whether we are using -// std::map or not -#ifdef RCPP_USING_MAP - -template -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/functions/unique.h b/inst/include/Rcpp/sugar/functions/unique.h index a0a721c3c..5143943b0 100644 --- a/inst/include/Rcpp/sugar/functions/unique.h +++ b/inst/include/Rcpp/sugar/functions/unique.h @@ -69,8 +69,8 @@ inline Vector unique( const VectorBase& t ){ return hash.keys() ; } template -inline Vector sort_unique( const VectorBase& t ){ - return unique( t ).sort() ; +inline Vector sort_unique( const VectorBase& t , bool decreasing = false){ + return unique( t ).sort(decreasing) ; } template 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/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/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 new file mode 100644 index 000000000..4aa64399b --- /dev/null +++ b/inst/include/Rcpp/traits/index_sequence.h @@ -0,0 +1,22 @@ +#ifndef RCPP_TRAITS_INDEX_SEQUENCE_H +#define RCPP_TRAITS_INDEX_SEQUENCE_H + +namespace Rcpp { +namespace traits { + /** + * C++11 implementations for index_sequence and make_index_sequence. + * To avoid name conflicts or ambiguity when compiling with C++14 or later, + * they should always be prefaced with `Rcpp::traits::` when used. + */ + template + struct index_sequence {}; + + template + struct make_index_sequence : make_index_sequence {}; + + template + struct make_index_sequence<0, Is...> : index_sequence {}; +} +} + +#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 761ac24de..e1fd2476a 100644 --- a/inst/include/Rcpp/traits/named_object.h +++ b/inst/include/Rcpp/traits/named_object.h @@ -1,9 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -/* :tabSize=4:indentSize=4:noTabs=false:folding=explicit:collapseFolds=1: */ -// + // named_object.h: Rcpp R/C++ interface class library -- named SEXP // -// Copyright (C) 2010 - 2017 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2020 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 - 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -23,6 +22,8 @@ #ifndef Rcpp__traits__named_object__h #define Rcpp__traits__named_object__h +#include + namespace Rcpp{ class Argument ; @@ -41,19 +42,22 @@ template class named_object { template <> class named_object { public: // #nocov start named_object( const std::string& name_, const SEXP& o_): - name(name_), object(o_) { - R_PreserveObject(object); + name(name_), object(o_), token(R_NilValue) { + token = Rcpp_PreciousPreserve(object); } named_object( const named_object& other ) : - name(other.name), object(other.object) { - R_PreserveObject(object); + name(other.name), object(other.object), token(other.token) { + token = Rcpp_PreciousPreserve(object); } ~named_object() { - R_ReleaseObject(object); + Rcpp_PreciousRelease(token); + } // #nocov end const std::string& name; SEXP object; +private: + SEXP token; }; @@ -61,6 +65,16 @@ 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 {}; + +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 7944aab81..752a25c1c 100644 --- a/inst/include/Rcpp/unwindProtect.h +++ b/inst/include/Rcpp/unwindProtect.h @@ -1,6 +1,8 @@ + // unwind.h: Rcpp R/C++ interface class library -- Unwind Protect // -// Copyright (C) 2018 RStudio +// Copyright (C) 2018 - 2020 RStudio +// Copyright (C) 2021 - 2025 RStudio, Dirk Eddelbuettel and Iñaki Ucar // // This file is part of Rcpp. // @@ -21,11 +23,7 @@ #define RCPP_UNWINDPROTECT_H #include - -#ifdef RCPP_USING_CXX11 #include -#endif - namespace Rcpp { namespace internal { @@ -43,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 @@ -74,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/Matrix.h b/inst/include/Rcpp/vector/Matrix.h index 2eb857fb3..c34843a58 100644 --- a/inst/include/Rcpp/vector/Matrix.h +++ b/inst/include/Rcpp/vector/Matrix.h @@ -50,7 +50,7 @@ class Matrix : public Vector, public MatrixBase( x ) ), nrows( VECTOR::dims()[0] ) {} + Matrix(SEXP x) : VECTOR(x), nrows( VECTOR::dims()[0] ) {} Matrix( const Dimension& dims) : VECTOR( Rf_allocMatrix( RTYPE, dims[0], dims[1] ) ), nrows(dims[0]) { if( dims.size() != 2 ) throw not_a_matrix(); @@ -269,8 +269,7 @@ RCPP_GENERATE_MATRIX_SCALAR_OPERATOR(/) inline typename traits::enable_if< traits::is_convertible< typename traits::remove_const_and_reference< T >::type, \ typename Matrix::stored_type >::value, Matrix >::type \ operator __OPERATOR__ (const T &lhs, const Matrix &rhs) { \ - Vector v = static_cast &>(rhs); \ - v = lhs __OPERATOR__ v; \ + Vector v = lhs __OPERATOR__ static_cast &>(rhs); \ v.attr("dim") = Vector::create(rhs.nrow(), rhs.ncol()); \ return as< Matrix >(v); \ } diff --git a/inst/include/Rcpp/vector/MatrixColumn.h b/inst/include/Rcpp/vector/MatrixColumn.h index d3f3144f5..4154b61be 100644 --- a/inst/include/Rcpp/vector/MatrixColumn.h +++ b/inst/include/Rcpp/vector/MatrixColumn.h @@ -129,7 +129,7 @@ class ConstMatrixColumn : public VectorBase ConstMatrixColumn( const MATRIX& parent, int i ) : n(parent.nrow()), - const_start(parent.begin() + i *n) + const_start(parent.begin() + static_cast(i) * n) { if( i < 0 || i >= parent.ncol() ) { const char* fmt = "Column index is out of bounds: " diff --git a/inst/include/Rcpp/vector/MatrixRow.h b/inst/include/Rcpp/vector/MatrixRow.h index 5d575f9b2..5c1a28b5e 100644 --- a/inst/include/Rcpp/vector/MatrixRow.h +++ b/inst/include/Rcpp/vector/MatrixRow.h @@ -169,7 +169,7 @@ class MatrixRow : public VectorBase< RTYPE, true, MatrixRow > { } inline reference operator[]( int i ) const { - return parent[ row + i * parent_nrow ] ; + return parent[ row + static_cast(i) * parent_nrow ] ; } inline iterator begin(){ @@ -206,9 +206,9 @@ class MatrixRow : public VectorBase< RTYPE, true, MatrixRow > { int parent_nrow ; int row ; - inline int get_parent_index(int i) const { - RCPP_DEBUG_4( "MatrixRow<%d>::get_parent_index(int = %d), parent_nrow = %d >> %d\n", RTYPE, i, parent_nrow, i*parent_nrow ) - return i * parent_nrow ; + inline R_xlen_t get_parent_index(int i) const { + RCPP_DEBUG_4( "MatrixRow<%d>::get_parent_index(int = %d), parent_nrow = %d >> %d\n", RTYPE, i, parent_nrow, static_cast(i) * parent_nrow ) + return static_cast(i) * parent_nrow ; } } ; @@ -310,7 +310,7 @@ class ConstMatrixRow : public VectorBase< RTYPE, true, ConstMatrixRow > { {} ; inline const_reference operator[]( int i ) const { - return parent[ row + i * parent_nrow ] ; + return parent[ row + static_cast(i) * parent_nrow ] ; } inline const_iterator begin() const { @@ -331,9 +331,9 @@ class ConstMatrixRow : public VectorBase< RTYPE, true, ConstMatrixRow > { int parent_nrow ; int row ; - inline int get_parent_index(int i) const { - RCPP_DEBUG_4( "ConstMatrixRow<%d>::get_parent_index(int = %d), parent_nrow = %d >> %d\n", RTYPE, i, parent_nrow, i*parent_nrow ) - return i * parent_nrow ; + inline R_xlen_t get_parent_index(int i) const { + RCPP_DEBUG_4( "ConstMatrixRow<%d>::get_parent_index(int = %d), parent_nrow = %d >> %d\n", RTYPE, i, parent_nrow, static_cast(i) * parent_nrow ) + return static_cast(i) * parent_nrow ; } } ; } diff --git a/inst/include/Rcpp/vector/SubMatrix.h b/inst/include/Rcpp/vector/SubMatrix.h index 98b417291..0bda3ab57 100644 --- a/inst/include/Rcpp/vector/SubMatrix.h +++ b/inst/include/Rcpp/vector/SubMatrix.h @@ -1,5 +1,4 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // SubMatrix.h: Rcpp R/C++ interface class library -- sub matrices // // Copyright (C) 2010 - 2013 Dirk Eddelbuettel and Romain Francois @@ -40,8 +39,8 @@ class SubMatrix : public Rcpp::MatrixBase< RTYPE, true, SubMatrix > { {} inline R_xlen_t size() const { return ((R_xlen_t)ncol()) * nrow() ; } - inline int ncol() const { return nc ; } - inline int nrow() const { return nr ; } + inline R_xlen_t ncol() const { return nc ; } + inline R_xlen_t nrow() const { return nr ; } inline Proxy operator()(int i, int j) const { return iter[ i + j*m_nr ] ; @@ -52,16 +51,16 @@ class SubMatrix : public Rcpp::MatrixBase< RTYPE, true, SubMatrix > { private: MATRIX& m ; vec_iterator iter ; - int m_nr, nc, nr ; + R_xlen_t m_nr, nc, nr ; } ; template class StoragePolicy > -Matrix::Matrix( const SubMatrix& sub ) : VECTOR( Rf_allocMatrix( RTYPE, sub.nrow(), sub.ncol() )), nrows(sub.nrow()) { - int nc = sub.ncol() ; +Matrix::Matrix( const SubMatrix& sub ) : VECTOR( Rf_allocMatrix( RTYPE, (int)sub.nrow(), (int)sub.ncol() )), nrows((int)sub.nrow()) { + R_xlen_t nc = sub.ncol() ; iterator start = VECTOR::begin() ; iterator rhs_it ; - for( int j=0; j + namespace Rcpp { template < @@ -51,47 +53,47 @@ class SubsetProxy { // Enable e.g. x[y] = z template class OtherStoragePolicy> SubsetProxy& operator=(const Vector& other) { - int n = other.size(); + R_xlen_t n = other.size(); if (n == 1) { - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { lhs[ indices[i] ] = other[0]; } } else if (n == indices_n) { - for (int i=0; i < n; ++i) { + for (R_xlen_t i=0; i < n; ++i) { lhs[ indices[i] ] = other[i]; } } else { stop("index error"); } return *this; - } + } // Enable e.g. x[y] = 1; // TODO: std::enable_if with C++11 SubsetProxy& operator=(double other) { - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { lhs[ indices[i] ] = other; } return *this; } SubsetProxy& operator=(int other) { - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { lhs[ indices[i] ] = other; } return *this; } SubsetProxy& operator=(const char* other) { - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { lhs[ indices[i] ] = other; } return *this; } SubsetProxy& operator=(bool other) { - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { lhs[ indices[i] ] = other; } return *this; @@ -107,12 +109,12 @@ class SubsetProxy { SubsetProxy& operator=(const SubsetProxy& other) { if (other.indices_n == 1) { - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { lhs[ indices[i] ] = other.lhs[other.indices[0]]; } } else if (indices_n == other.indices_n) { - for (int i=0; i < indices_n; ++i) + for (R_xlen_t i=0; i < indices_n; ++i) lhs[ indices[i] ] = other.lhs[other.indices[i]]; } else { @@ -131,35 +133,38 @@ class SubsetProxy { private: - #ifndef RCPP_NO_BOUNDS_CHECK - void check_indices(int* x, int n, int size) { - for (int i=0; i < n; ++i) { + template + void check_indices(IDX* x, R_xlen_t n, R_xlen_t size) { +#ifndef RCPP_NO_BOUNDS_CHECK + for (IDX i=0; i < n; ++i) { if (x[i] < 0 or x[i] >= size) { + if(std::numeric_limits::is_integer && size > std::numeric_limits::max()) { + stop("use NumericVector to index an object of length %td", size); + } stop("index error"); } } +#endif } - #else - void check_indices(int* x, int n, int size) {} - #endif void get_indices( traits::identity< traits::int2type > t ) { indices.reserve(rhs_n); - int* ptr = INTEGER(rhs); + int* ptr = INTEGER(rhs); // ok to use int * here, we'll catch any problems inside check_indices check_indices(ptr, rhs_n, lhs_n); - for (int i=0; i < rhs_n; ++i) { + for (R_xlen_t i=0; i < rhs_n; ++i) { indices.push_back( rhs[i] ); } - indices_n = rhs_n; + indices_n = rhs_n; } void get_indices( traits::identity< traits::int2type > t ) { indices.reserve(rhs_n); - Vector tmp = - as< Vector >(rhs); - int* ptr = INTEGER(tmp); - check_indices(ptr, rhs_n, lhs_n); - for (int i=0; i < rhs_n; ++i) { + std::vector tmp(rhs.size()); // create temp R_xlen_t type indices from reals + for(size_t i = 0 ; i < tmp.size() ; ++i) { + tmp[i] = rhs[i]; + } + check_indices(&tmp[0], rhs_n, lhs_n); + for (R_xlen_t i=0; i < rhs_n; ++i) { indices.push_back( tmp[i] ); } indices_n = rhs_n; @@ -169,10 +174,10 @@ class SubsetProxy { indices.reserve(rhs_n); SEXP names = Rf_getAttrib(lhs, R_NamesSymbol); if (Rf_isNull(names)) stop("names is null"); - SEXP* namesPtr = STRING_PTR(names); - SEXP* rhsPtr = STRING_PTR(rhs); - for (int i = 0; i < rhs_n; ++i) { - SEXP* match = std::find(namesPtr, namesPtr + lhs_n, *(rhsPtr + i)); + const SEXP* namesPtr = RCPP_STRING_PTR(names); + const SEXP* rhsPtr = RCPP_STRING_PTR(rhs); + for (R_xlen_t i = 0; i < rhs_n; ++i) { + const SEXP* match = std::find(namesPtr, namesPtr + lhs_n, *(rhsPtr + i)); if (match == namesPtr + lhs_n) stop("not found"); indices.push_back(match - namesPtr); @@ -186,7 +191,7 @@ class SubsetProxy { stop("logical subsetting requires vectors of identical size"); } int* ptr = LOGICAL(rhs); - for (int i=0; i < rhs_n; ++i) { + for (R_xlen_t i=0; i < rhs_n; ++i) { if (ptr[i] == NA_INTEGER) { stop("can't subset using a logical vector with NAs"); } @@ -199,13 +204,13 @@ class SubsetProxy { Vector get_vec() const { Vector output = no_init(indices_n); - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { output[i] = lhs[ indices[i] ]; } SEXP names = Rf_getAttrib(lhs, R_NamesSymbol); if (!Rf_isNull(names)) { Shield out_names( Rf_allocVector(STRSXP, indices_n) ); - for (int i=0; i < indices_n; ++i) { + for (R_xlen_t i=0; i < indices_n; ++i) { SET_STRING_ELT(out_names, i, STRING_ELT(names, indices[i])); } Rf_setAttrib(output, R_NamesSymbol, out_names); @@ -216,13 +221,13 @@ class SubsetProxy { LHS_t& lhs; const RHS_t& rhs; - int lhs_n; - int rhs_n; + R_xlen_t lhs_n; + R_xlen_t rhs_n; - std::vector indices; + std::vector indices; // because of the above, we keep track of the size - int indices_n; + R_xlen_t indices_n; public: @@ -234,10 +239,10 @@ class SubsetProxy { RHS_NA_OTHER, RHS_T_OTHER>& other) { \ Vector result(indices_n); \ if (other.indices_n == 1) { \ - for (int i = 0; i < indices_n; ++i) \ + for (R_xlen_t i = 0; i < indices_n; ++i) \ result[i] = lhs[indices[i]] __OPERATOR__ other.lhs[other.indices[0]]; \ } else if (indices_n == other.indices_n) { \ - for (int i = 0; i < indices_n; ++i) \ + for (R_xlen_t i = 0; i < indices_n; ++i) \ result[i] = lhs[indices[i]] __OPERATOR__ other.lhs[other.indices[i]]; \ } else { \ stop("index error"); \ diff --git a/inst/include/Rcpp/vector/Vector.h b/inst/include/Rcpp/vector/Vector.h index e2fe96772..76bc56020 100644 --- a/inst/include/Rcpp/vector/Vector.h +++ b/inst/include/Rcpp/vector/Vector.h @@ -1,8 +1,6 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// // Vector.h: Rcpp R/C++ interface class library -- vectors // -// Copyright (C) 2010 - 2018 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2026 Dirk Eddelbuettel and Romain Francois // // This file is part of Rcpp. // @@ -71,12 +69,14 @@ class Vector : } Vector( SEXP x ) { - Storage::set__( r_cast(x) ) ; + Rcpp::Shield safe(x); + Storage::set__( r_cast(safe) ) ; } template Vector( const GenericProxy& proxy ){ - Storage::set__( r_cast(proxy.get()) ) ; + Rcpp::Shield safe(proxy.get()); + Storage::set__( r_cast(safe) ) ; } explicit Vector( const no_init_vector& obj) { @@ -174,7 +174,8 @@ class Vector : template Vector( const sugar::SingleLogicalResult& obj ) { - Storage::set__( r_cast( const_cast&>(obj).get_sexp() ) ) ; + Rcpp::Shield safe(const_cast&>(obj).get_sexp() ); + Storage::set__( r_cast(safe) ) ; RCPP_DEBUG_2( "Vector<%d>( const sugar::SingleLogicalResult& ) [T = %s]", RTYPE, DEMANGLE(T) ) } @@ -235,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) { @@ -298,12 +297,12 @@ class Vector : * one dimensional offset doing bounds checking to ensure * it is valid */ - R_xlen_t offset(const R_xlen_t& i) const { + R_xlen_t offset(const R_xlen_t& i) const { // #nocov start if(i < 0 || i >= ::Rf_xlength(Storage::get__()) ) { const char* fmt = "Index out of bounds: [index=%i; extent=%i]."; throw index_out_of_bounds(fmt, i, ::Rf_xlength(Storage::get__()) ) ; } - return i ; + return i ; // #nocov end } R_xlen_t offset(const std::string& name) const { @@ -330,7 +329,7 @@ class Vector : } inline iterator begin() { return cache.get() ; } - inline iterator end() { return cache.get() + 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() ; } @@ -346,12 +345,12 @@ 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 { return cache.ref( offset(i) ) ; - } + } // #nocov end inline Proxy operator()( const size_t& i, const size_t& j) { return cache.ref( offset(i,j) ) ; @@ -592,7 +591,7 @@ class Vector : return false ; } - int findName(const std::string& name) const { + R_xlen_t findName(const std::string& name) const { SEXP names = RCPP_GET_NAMES(Storage::get__()); if (Rf_isNull(names)) stop("'names' attribute is null"); R_xlen_t n = Rf_xlength(names); @@ -629,7 +628,7 @@ class Vector : iterator this_end(end()); if( Rf_isNull(names) ){ for( ; it < this_end; ++it, ++target_it ){ - *target_it = *it ; + *target_it = *it ; // #nocov start } } else { Shield newnames( ::Rf_allocVector( STRSXP, n + 1) ) ; @@ -639,7 +638,7 @@ class Vector : SET_STRING_ELT( newnames, i, STRING_ELT(names, i ) ) ; } SET_STRING_ELT( newnames, i, Rf_mkChar("") ) ; - target.attr("names") = newnames ; + target.attr("names") = newnames ; // #nocov end } *target_it = object_sexp; Storage::set__( target.get__() ) ; @@ -682,8 +681,8 @@ class Vector : int i=0; if( Rf_isNull(names) ){ for( ; it < this_end; ++it, ++target_it,i++ ){ - *target_it = *it ; - SET_STRING_ELT( newnames, i , R_BlankString ); + *target_it = *it ; // #nocov + SET_STRING_ELT( newnames, i , R_BlankString ); // #nocov } } else { for( ; it < this_end; ++it, ++target_it, i++ ){ @@ -1121,16 +1120,64 @@ class Vector : return Vector( 0 ) ; } - #include +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); + } + + 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: inline SEXP eval() const { - return Rcpp_fast_eval( Storage::get__(), R_GlobalEnv ) ; + return Rcpp_eval( Storage::get__(), R_GlobalEnv ) ; } inline SEXP eval(SEXP env) const { - return Rcpp_fast_eval( Storage::get__(), env ); + return Rcpp_eval( Storage::get__(), env ); } 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 1e01d93dc..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. // @@ -35,22 +34,36 @@ namespace traits{ typedef typename r_vector_const_proxy::type const_proxy ; typedef typename storage_type::type storage_type ; - r_vector_cache() : start(0){} ; + r_vector_cache() : start(0), size(0) {} ; + inline void update( const VECTOR& v ) { - start = ::Rcpp::internal::r_vector_start(v) ; + start = ::Rcpp::internal::r_vector_start(v) ; + size = v.size(); } + inline iterator get() const { return start; } inline const_iterator get_const() const { return start; } - inline proxy ref() { return *start ;} - inline proxy ref(R_xlen_t i) { return start[i] ; } + inline proxy ref() { check_index(0); return start[0] ;} + inline proxy ref(R_xlen_t i) { check_index(i); return start[i] ; } - inline proxy ref() const { return *start ;} - inline proxy ref(R_xlen_t i) const { return start[i] ; } + inline proxy ref() const { check_index(0); return start[0] ;} + inline proxy ref(R_xlen_t i) const { check_index(i); return start[i] ; } - private: - iterator start ; + private: + + 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); // #nocov + } +#endif + } + + iterator start ; + R_xlen_t size ; } ; + template class StoragePolicy = PreserveStorage> class proxy_cache{ public: @@ -66,17 +79,24 @@ namespace traits{ p = const_cast(&v) ; } inline iterator get() const { return iterator( proxy(*p, 0 ) ) ;} - // inline const_iterator get_const() const { return const_iterator( *p ) ;} inline const_iterator get_const() const { return const_iterator( const_proxy(*p, 0) ) ; } - inline proxy ref() { return proxy(*p,0) ; } - inline proxy ref(R_xlen_t i) { return proxy(*p,i);} + inline proxy ref() { check_index(0); return proxy(*p,0) ; } + inline proxy ref(R_xlen_t i) { check_index(i); return proxy(*p,i);} - inline const_proxy ref() const { return const_proxy(*p,0) ; } - inline const_proxy ref(R_xlen_t i) const { return const_proxy(*p,i);} + inline const_proxy ref() const { check_index(0); return const_proxy(*p,0) ; } + inline const_proxy ref(R_xlen_t i) const { check_index(i); return const_proxy(*p,i);} private: VECTOR* p ; + + 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()); // #nocov + } +#endif + } } ; // regular types for INTSXP, REALSXP, ... diff --git a/inst/include/RcppCommon.h b/inst/include/RcppCommon.h index f3e5bb243..ea23f5e82 100644 --- a/inst/include/RcppCommon.h +++ b/inst/include/RcppCommon.h @@ -1,9 +1,9 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // RcppCommon.h: Rcpp R/C++ interface class library -- common include and defines statements // // Copyright (C) 2008 - 2009 Dirk Eddelbuettel -// Copyright (C) 2009 - 2017 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2009 - 2020 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 - 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -26,7 +26,9 @@ // #define RCPP_DEBUG_LEVEL 1 // #define RCPP_DEBUG_MODULE_LEVEL 1 +#include #include +#include /** * \brief Rcpp API @@ -52,6 +54,9 @@ namespace Rcpp { #include #include #include +#if __cplusplus >= 201703L +#include +#endif #include #include #include @@ -62,11 +67,11 @@ namespace Rcpp { #include #include #include +#include #include #include +#include #include -#include -#include #include #include @@ -77,6 +82,9 @@ namespace Rcpp { SEXP Rcpp_fast_eval(SEXP expr_, SEXP env); SEXP Rcpp_eval(SEXP expr_, SEXP env = R_GlobalEnv); + SEXP Rcpp_precious_preserve(SEXP object); + void Rcpp_precious_remove(SEXP token); + namespace internal { SEXP Rcpp_eval_impl(SEXP expr, SEXP env); } @@ -87,38 +95,33 @@ namespace Rcpp { template class named_object; } + // begin deprecated interface not using precious list + // use Rcpp_PreciousPreserve + Rcpp_PreciousRelease below it inline SEXP Rcpp_PreserveObject(SEXP x) { - if (x != R_NilValue) { - R_PreserveObject(x); - } + if (x != R_NilValue) R_PreserveObject(x); return x; } - inline void Rcpp_ReleaseObject(SEXP x) { - if (x != R_NilValue) { - R_ReleaseObject(x); - } + if (x != R_NilValue) R_ReleaseObject(x); } - inline SEXP Rcpp_ReplaceObject(SEXP x, SEXP y) { - if (Rf_isNull(x)) { + // if we are setting to the same SEXP as we already have, do nothing + if (x != y) { + Rcpp_ReleaseObject(x); Rcpp_PreserveObject(y); - } else if (Rf_isNull(y)) { - Rcpp_ReleaseObject(x); // #nocov - } else { - // if we are setting to the same SEXP as we already have, do nothing - if (x != y) { - - // the previous SEXP was not NULL, so release it - Rcpp_ReleaseObject(x); - - // the new SEXP is not NULL, so preserve it - Rcpp_PreserveObject(y); - - } } return y; } + // end deprecated interface not using precious list + + // new preferred interface using token-based precious list + inline SEXP Rcpp_PreciousPreserve(SEXP object) { + return Rcpp_precious_preserve(object); + } + + inline void Rcpp_PreciousRelease(SEXP token) { + Rcpp_precious_remove(token); + } } @@ -128,9 +131,7 @@ namespace Rcpp { #include #include -#ifdef RCPP_USING_UNWIND_PROTECT - #include -#endif +#include #include #include @@ -186,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/unitTests/bin/amd64/r-cran-testrcpppackage_0.1.0-1_amd64.deb b/inst/tinytest/bin/amd64/r-cran-testrcpppackage_0.1.0-1_amd64.deb similarity index 100% rename from inst/unitTests/bin/amd64/r-cran-testrcpppackage_0.1.0-1_amd64.deb rename to inst/tinytest/bin/amd64/r-cran-testrcpppackage_0.1.0-1_amd64.deb diff --git a/inst/unitTests/bin/i386/r-cran-testrcpppackage_0.1.0-1_i386.deb b/inst/tinytest/bin/i386/r-cran-testrcpppackage_0.1.0-1_i386.deb similarity index 100% rename from inst/unitTests/bin/i386/r-cran-testrcpppackage_0.1.0-1_i386.deb rename to inst/tinytest/bin/i386/r-cran-testrcpppackage_0.1.0-1_i386.deb diff --git a/inst/tinytest/cpp/DataFrame.cpp b/inst/tinytest/cpp/DataFrame.cpp new file mode 100644 index 000000000..fff7e4d96 --- /dev/null +++ b/inst/tinytest/cpp/DataFrame.cpp @@ -0,0 +1,208 @@ +// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- +// +// DataFrame.cpp: Rcpp R/C++ interface class library -- DataFrame unit tests +// +// 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 . + +#include +using namespace Rcpp ; + +// [[Rcpp::export]] +DataFrame FromSEXP( SEXP x){ + DataFrame df(x) ; + return df; +} + +// [[Rcpp::export]] +SEXP index_byName( DataFrame df, std::string s ){ + return df[s]; +} + +// [[Rcpp::export]] +SEXP index_byPosition( DataFrame df, int i ){ + return df[i]; +} +// [[Rcpp::export]] +std::string string_element( DataFrame df ){ + CharacterVector b = df[1]; + std::string s; + s = b[1]; + return s; +} + +// [[Rcpp::export]] +DataFrame createOne(){ + IntegerVector v = IntegerVector::create(1,2,3); + return DataFrame::create(Named("a")=v); +} + +// [[Rcpp::export]] +DataFrame createTwo(){ + IntegerVector v = IntegerVector::create(1,2,3); + std::vector s(3); + s[0] = "a"; + s[1] = "b"; + s[2] = "c"; + return DataFrame::create(Named("a")=v, Named("b")=s); +} + +// [[Rcpp::export]] +DataFrame SlotProxy( S4 o, std::string yy ){ + return DataFrame( o.slot( yy ) ) ; +} + +// [[Rcpp::export]] +DataFrame AttributeProxy( List o, std::string y ){ + return DataFrame( o.attr( y )) ; +} + +// [[Rcpp::export]] +DataFrame createTwoStringsAsFactors(){ + IntegerVector v = IntegerVector::create(1,2,3); + std::vector s(3); + s[0] = "a"; + s[1] = "b"; + s[2] = "c"; + return DataFrame::create( + _["a"] = v, + _["b"] = s, + _["stringsAsFactors"] = false ); +} + +// [[Rcpp::export]] +IntegerVector DataFrame_nrow( DataFrame df){ + return IntegerVector::create(df.nrow(), df.rows()) ; +} + + +// [[Rcpp::export]] +IntegerVector DataFrame_ncol( DataFrame df){ + return IntegerVector::create(df.ncol(), df.cols()); +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushBackNamed(){ + NumericVector u(2); + NumericVector v(2); + DataFrame df = DataFrame::create(_["u"] = u); + df.push_back(v, "v"); + return df; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushBackUnnamed(){ + NumericVector u(2); + NumericVector v(2); + DataFrame df = DataFrame::create(_["u"] = u); + df.push_back(v); + return df; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushFrontNamed(){ + NumericVector u(2); + NumericVector v(2); + DataFrame df = DataFrame::create(_["u"] = u); + df.push_front(v, "v"); + return df; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushFrontUnnamed(){ + NumericVector u(2); + NumericVector v(2); + DataFrame df = DataFrame::create(_["u"] = u); + df.push_front(v); + return df; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushFrontDataFrame(){ + NumericVector u(2); + NumericVector v(2); + NumericVector w(2); + NumericVector x(2); + + DataFrame df1 = DataFrame::create(_["u"] = u, _["v"] = v); + DataFrame df2 = DataFrame::create(_["w"] = w, _["x"] = x); + df1.push_front(df2); + return df1; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushBackDataFrame(){ + NumericVector u(2); + NumericVector v(2); + NumericVector w(2); + NumericVector x(2); + + DataFrame df1 = DataFrame::create(_["u"] = u, _["v"] = v); + DataFrame df2 = DataFrame::create(_["w"] = w, _["x"] = x); + df1.push_back(df2); + return df1; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushWrongSize(){ + NumericVector u(2); + NumericVector v(3); + + DataFrame df1 = DataFrame::create(_["u"] = u); + df1.push_back(v); + return df1; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushReplicateLength(){ + NumericVector u(2); + NumericVector v(4); + NumericVector x(1); + + u[0] = 1; + x[0] = 2; + + DataFrame df1 = DataFrame::create(_["u"] = u); + df1.push_back(v, "v"); + df1.push_back(x, "x"); + return df1; +} + +// [[Rcpp::export]] +DataFrame DataFrame_PushZeroLength(){ + NumericVector u(2); + NumericVector v(0); + + + DataFrame df1 = DataFrame::create(_["u"] = u); + df1.push_back(v); + return df1; +} + +// issue #1232 +// [[Rcpp::export]] +Rcpp::DataFrame DataFrame_PushOnEmpty() { + int n = 0; + Rcpp::IntegerVector foo(n); + Rcpp::CharacterVector bar(n); + Rcpp::CharacterVector baz(n); + + Rcpp::List ll = Rcpp::List::create(Rcpp::Named("foo") = foo, + Rcpp::Named("bar") = bar); + ll.push_back(baz, "baz"); + return Rcpp::DataFrame(ll); +} diff --git a/inst/unitTests/cpp/Environment.cpp b/inst/tinytest/cpp/Environment.cpp similarity index 100% rename from inst/unitTests/cpp/Environment.cpp rename to inst/tinytest/cpp/Environment.cpp diff --git a/inst/unitTests/cpp/Exceptions_nocall.cpp b/inst/tinytest/cpp/Exceptions_nocall.cpp similarity index 100% rename from inst/unitTests/cpp/Exceptions_nocall.cpp rename to inst/tinytest/cpp/Exceptions_nocall.cpp diff --git a/inst/unitTests/cpp/Function.cpp b/inst/tinytest/cpp/Function.cpp similarity index 100% rename from inst/unitTests/cpp/Function.cpp rename to inst/tinytest/cpp/Function.cpp diff --git a/inst/unitTests/cpp/InternalFunction.cpp b/inst/tinytest/cpp/InternalFunction.cpp similarity index 84% rename from inst/unitTests/cpp/InternalFunction.cpp rename to inst/tinytest/cpp/InternalFunction.cpp index c6d2515eb..7261da9c8 100644 --- a/inst/unitTests/cpp/InternalFunction.cpp +++ b/inst/tinytest/cpp/InternalFunction.cpp @@ -27,6 +27,15 @@ int add(int a, int b) { return a + b; } +void dummy(int a, int b) { + Rcpp::Rcout << "dummy called" << std::endl; +} + +// [[Rcpp::export]] +Rcpp::InternalFunction getDummy() { + return Rcpp::InternalFunction( &dummy ); +} + // [[Rcpp::export]] Rcpp::InternalFunction getAdd() { diff --git a/inst/unitTests/cpp/InternalFunctionCPP11.cpp b/inst/tinytest/cpp/InternalFunctionCPP11.cpp similarity index 100% rename from inst/unitTests/cpp/InternalFunctionCPP11.cpp rename to inst/tinytest/cpp/InternalFunctionCPP11.cpp diff --git a/inst/unitTests/cpp/ListOf.cpp b/inst/tinytest/cpp/ListOf.cpp similarity index 100% rename from inst/unitTests/cpp/ListOf.cpp rename to inst/tinytest/cpp/ListOf.cpp diff --git a/inst/unitTests/cpp/Matrix.cpp b/inst/tinytest/cpp/Matrix.cpp similarity index 94% rename from inst/unitTests/cpp/Matrix.cpp rename to inst/tinytest/cpp/Matrix.cpp index 71e054f43..aa9b2a27a 100644 --- a/inst/unitTests/cpp/Matrix.cpp +++ b/inst/tinytest/cpp/Matrix.cpp @@ -337,6 +337,20 @@ NumericMatrix matrix_scalar_plus2(const NumericMatrix & x, double y) { return y + x; } +// [[Rcpp::export]] +NumericMatrix matrix_scalar_plus3(const NumericMatrix & x, double y) { + NumericMatrix z(x.rows(), x.cols()); + z = x + y; + return x; +} + +// [[Rcpp::export]] +NumericMatrix matrix_scalar_plus4(const NumericMatrix & x, double y) { + NumericMatrix z(x.rows(), x.cols()); + z = y + x; + return x; +} + // [[Rcpp::export]] NumericMatrix matrix_scalar_divide(const NumericMatrix & x, double y) { return x / y; @@ -347,6 +361,20 @@ NumericMatrix matrix_scalar_divide2(const NumericMatrix & x, double y) { return y / x; } +// [[Rcpp::export]] +NumericMatrix matrix_scalar_divide3(const NumericMatrix & x, double y) { + NumericMatrix z(x.rows(), x.cols()); + z = x / y; + return x; +} + +// [[Rcpp::export]] +NumericMatrix matrix_scalar_divide4(const NumericMatrix & x, double y) { + NumericMatrix z(x.rows(), x.cols()); + z = y / x; + return x; +} + // 24 October 2016 // eye, ones, and zeros static member functions diff --git a/inst/unitTests/cpp/Module.cpp b/inst/tinytest/cpp/Module.cpp similarity index 100% rename from inst/unitTests/cpp/Module.cpp rename to inst/tinytest/cpp/Module.cpp diff --git a/inst/unitTests/cpp/RObject.cpp b/inst/tinytest/cpp/RObject.cpp similarity index 100% rename from inst/unitTests/cpp/RObject.cpp rename to inst/tinytest/cpp/RObject.cpp diff --git a/inst/unitTests/cpp/Reference.cpp b/inst/tinytest/cpp/Reference.cpp similarity index 100% rename from inst/unitTests/cpp/Reference.cpp rename to inst/tinytest/cpp/Reference.cpp diff --git a/inst/unitTests/cpp/S4.cpp b/inst/tinytest/cpp/S4.cpp similarity index 100% rename from inst/unitTests/cpp/S4.cpp rename to inst/tinytest/cpp/S4.cpp diff --git a/inst/unitTests/cpp/String.cpp b/inst/tinytest/cpp/String.cpp similarity index 76% rename from inst/unitTests/cpp/String.cpp rename to inst/tinytest/cpp/String.cpp index 4adf839df..5d12a2165 100644 --- a/inst/unitTests/cpp/String.cpp +++ b/inst/tinytest/cpp/String.cpp @@ -53,6 +53,35 @@ String test_ctor(String x) { return test; } +// [[Rcpp::export]] +CharacterVector test_move_ctor() { + std::vector v = { "test" }; + String t = std::move( v[0] ); + v.push_back( std::move( t ) ); + return CharacterVector( v.begin(), v.end() ); +} + +// [[Rcpp::export]] +String test_move_std_string_ctor() { + std::string s = "test"; + return String( std::move( s ) ); +} + +// [[Rcpp::export]] +CharacterVector test_move_assignment() { + std::vector v = { "test", "abc" }; + v[1] = std::move( v[0] ); + return CharacterVector( v.begin(), v.end() ); +} + +// [[Rcpp::export]] +String test_move_std_string_assignment() { + String x = "abc"; + std::string s = "test"; + x = std::move( s ); + return x; +} + // [[Rcpp::export]] List test_compare_Strings( String aa, String bb ){ return List::create( @@ -114,3 +143,9 @@ String test_String_ctor_encoding2() { y.set_encoding(CE_UTF8); return y; } + +// [[Rcpp::export]] +String test_String_embeddedNul() { + std::string bad("abc\0abc", 7); + return String(bad); +} diff --git a/inst/unitTests/cpp/Subset.cpp b/inst/tinytest/cpp/Subset.cpp similarity index 100% rename from inst/unitTests/cpp/Subset.cpp rename to inst/tinytest/cpp/Subset.cpp diff --git a/inst/unitTests/cpp/Vector.cpp b/inst/tinytest/cpp/Vector.cpp similarity index 98% rename from inst/unitTests/cpp/Vector.cpp rename to inst/tinytest/cpp/Vector.cpp index d53e2986b..4fc26b7e8 100644 --- a/inst/unitTests/cpp/Vector.cpp +++ b/inst/tinytest/cpp/Vector.cpp @@ -805,7 +805,7 @@ LogicalVector logical_vector_from_bool_assign() { // [[Rcpp::export]] void no_op(int major) { - int minor = 1; + //int minor = 1; } // [[Rcpp::export]] @@ -886,3 +886,13 @@ bool CharacterVector_test_equality_crosspolicy(CharacterVector x, Vector > p){ return p->front() ; } +// [[Rcpp::export]] +void xptr_self_tag( XPtr< std::vector > p ){ + XPtr< std::vector > self_tag(wrap(p), wrap(p), R_NilValue) ; +} + +// [[Rcpp::export]] +bool xptr_has_self_tag( XPtr< std::vector > p ){ + return wrap(p) == R_ExternalPtrTag(p); +} + + // [[Rcpp::export]] bool xptr_release( XPtr< std::vector > p) { p.release(); diff --git a/inst/unitTests/cpp/algorithm.cpp b/inst/tinytest/cpp/algorithm.cpp similarity index 100% rename from inst/unitTests/cpp/algorithm.cpp rename to inst/tinytest/cpp/algorithm.cpp diff --git a/inst/unitTests/cpp/as.cpp b/inst/tinytest/cpp/as.cpp similarity index 100% rename from inst/unitTests/cpp/as.cpp rename to inst/tinytest/cpp/as.cpp diff --git a/inst/unitTests/cpp/attributes.cpp b/inst/tinytest/cpp/attributes.cpp similarity index 52% rename from inst/unitTests/cpp/attributes.cpp rename to inst/tinytest/cpp/attributes.cpp index 8cd67ebd6..70215c32c 100644 --- a/inst/unitTests/cpp/attributes.cpp +++ b/inst/tinytest/cpp/attributes.cpp @@ -20,3 +20,18 @@ std::string parse_declaration_test(std::string msg) { // [[Rcpp::export]] std::string parse_declaration_test(std::string msg = "Parse function declaration"); + +// [[Rcpp::export]] +std::string parse_default_values_with_str_parenthesis(const char* a = "(", const char* b= ")", std::string msg = "Parse function header with parenthis inside default string values.") { + return msg; +} + +// [[Rcpp::export]] +std::string parse_default_values_with_chr_parenthesis(char a = '(', char b= ')', std::string msg = "Parse function header with parenthis inside default char values.") { + return msg; +} + +// [[Rcpp::export]] +std::string parse_default_values_with_chr_backslash(char a = '\\', std::string msg = "Parse function header with backslash inside default char values.") { + return msg; +} diff --git a/inst/unitTests/cpp/attributes.hpp b/inst/tinytest/cpp/attributes.hpp similarity index 100% rename from inst/unitTests/cpp/attributes.hpp rename to inst/tinytest/cpp/attributes.hpp diff --git a/inst/include/Rcpp/module/Module_generated_class_signature.h b/inst/tinytest/cpp/coerce.cpp similarity index 63% rename from inst/include/Rcpp/module/Module_generated_class_signature.h rename to inst/tinytest/cpp/coerce.cpp index 363d0cb1d..601465d8e 100644 --- a/inst/include/Rcpp/module/Module_generated_class_signature.h +++ b/inst/tinytest/cpp/coerce.cpp @@ -1,8 +1,8 @@ // -*- 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 +// coerce.cpp: Rcpp R/C++ interface class library -- coerce unit tests // -// Copyright (C) 2010 - 2011 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2022 Dirk Eddelbuettel and Kevin Ushey // // This file is part of Rcpp. // @@ -19,16 +19,10 @@ // 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 +using namespace Rcpp ; -inline bool yes( SEXP* /*args*/, int /* nargs */ ){ - return true ; +// [[Rcpp::export]] +std::string coerce_raw_to_string(Rbyte x) { + return internal::coerce_to_string(x); } - -template -bool yes_arity( SEXP* /* args */ , int nargs){ - return nargs == n ; -} - -#endif diff --git a/inst/unitTests/cpp/dates.cpp b/inst/tinytest/cpp/dates.cpp similarity index 95% rename from inst/unitTests/cpp/dates.cpp rename to inst/tinytest/cpp/dates.cpp index 6c5800e87..a175cc32f 100644 --- a/inst/unitTests/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/unitTests/cpp/dispatch.cpp b/inst/tinytest/cpp/dispatch.cpp similarity index 100% rename from inst/unitTests/cpp/dispatch.cpp rename to inst/tinytest/cpp/dispatch.cpp diff --git a/inst/unitTests/cpp/embeddedR.cpp b/inst/tinytest/cpp/embeddedR.cpp similarity index 100% rename from inst/unitTests/cpp/embeddedR.cpp rename to inst/tinytest/cpp/embeddedR.cpp diff --git a/inst/unitTests/cpp/embeddedR2.cpp b/inst/tinytest/cpp/embeddedR2.cpp similarity index 100% rename from inst/unitTests/cpp/embeddedR2.cpp rename to inst/tinytest/cpp/embeddedR2.cpp diff --git a/inst/unitTests/cpp/exceptions.cpp b/inst/tinytest/cpp/exceptions.cpp similarity index 100% rename from inst/unitTests/cpp/exceptions.cpp rename to inst/tinytest/cpp/exceptions.cpp diff --git a/inst/unitTests/cpp/language.cpp b/inst/tinytest/cpp/language.cpp similarity index 97% rename from inst/unitTests/cpp/language.cpp rename to inst/tinytest/cpp/language.cpp index c06c8a6fb..68aa58fe4 100644 --- a/inst/unitTests/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/unitTests/cpp/misc.cpp b/inst/tinytest/cpp/misc.cpp similarity index 98% rename from inst/unitTests/cpp/misc.cpp rename to inst/tinytest/cpp/misc.cpp index 8f2b18881..87271e5d3 100644 --- a/inst/unitTests/cpp/misc.cpp +++ b/inst/tinytest/cpp/misc.cpp @@ -224,3 +224,8 @@ String testNullableString(Rcpp::Nullable param = R_NilValue) { else return String(""); } + +// [[Rcpp::export]] +void messageWrapper(SEXP s) { + message(s); +} diff --git a/inst/unitTests/cpp/modref.cpp b/inst/tinytest/cpp/modref.cpp similarity index 100% rename from inst/unitTests/cpp/modref.cpp rename to inst/tinytest/cpp/modref.cpp diff --git a/inst/unitTests/cpp/na.cpp b/inst/tinytest/cpp/na.cpp similarity index 100% rename from inst/unitTests/cpp/na.cpp rename to inst/tinytest/cpp/na.cpp diff --git a/inst/tinytest/cpp/rcppversion.cpp b/inst/tinytest/cpp/rcppversion.cpp new file mode 100644 index 000000000..35b1028ed --- /dev/null +++ b/inst/tinytest/cpp/rcppversion.cpp @@ -0,0 +1,22 @@ +#include + +// [[Rcpp::export]] +Rcpp::List checkVersion(Rcpp::IntegerVector v) { + + // incoming, we expect v to have been made by + // as.integer(unlist(strsplit(as.character(packageVersion("Rcpp")), "\\."))) + // yielding eg + // c(1L, 0L, 3L, 1L) + + // ensure that length is four, after possibly appending 0 + if (v.size() == 3) v.push_back(0); + if (v.size() == 4) v.push_back(0); + if (v.size() > 5) Rcpp::stop("Expect vector with up to five elements."); + + return Rcpp::List::create(Rcpp::Named("def_ver") = RCPP_VERSION, + Rcpp::Named("def_str") = RCPP_VERSION_STRING, + Rcpp::Named("cur_ver") = Rcpp_Version(v[0], v[1], v[2]), + Rcpp::Named("def_dev_ver") = RCPP_DEV_VERSION, + Rcpp::Named("def_dev_str") = RCPP_DEV_VERSION_STRING, + Rcpp::Named("cur_dev_ver") = RcppDevVersion(v[0], v[1], v[2], v[3])); +} diff --git a/inst/unitTests/cpp/rmath.cpp b/inst/tinytest/cpp/rmath.cpp similarity index 100% rename from inst/unitTests/cpp/rmath.cpp rename to inst/tinytest/cpp/rmath.cpp diff --git a/inst/unitTests/cpp/stack.cpp b/inst/tinytest/cpp/stack.cpp similarity index 91% rename from inst/unitTests/cpp/stack.cpp rename to inst/tinytest/cpp/stack.cpp index 630a44ec7..a4a5c86eb 100644 --- a/inst/unitTests/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 - 2015 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. // @@ -19,7 +20,7 @@ // You should have received a copy of the GNU General Public License // along with Rcpp. If not, see . -// [[Rcpp::plugins(unwindProtect,cpp11)]] +// [[Rcpp::plugins(cpp11)]] #include using namespace 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/unitTests/cpp/stats.cpp b/inst/tinytest/cpp/stats.cpp similarity index 100% rename from inst/unitTests/cpp/stats.cpp rename to inst/tinytest/cpp/stats.cpp diff --git a/inst/unitTests/cpp/sugar.cpp b/inst/tinytest/cpp/sugar.cpp similarity index 93% rename from inst/unitTests/cpp/sugar.cpp rename to inst/tinytest/cpp/sugar.cpp index 04e56971d..d436559b9 100644 --- a/inst/unitTests/cpp/sugar.cpp +++ b/inst/tinytest/cpp/sugar.cpp @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// + // sugar.cpp: Rcpp R/C++ interface class library -- sugar unit tests // -// Copyright (C) 2012 - 2015 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2025 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -23,7 +23,7 @@ using namespace Rcpp ; template -class square : public std::unary_function { +class square : public std::function { public: T operator()( T t) const { return t*t ; } } ; @@ -222,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( @@ -327,6 +374,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 ); @@ -444,6 +497,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( @@ -611,6 +670,12 @@ Rcpp::CharacterVector runit_unique_ch(Rcpp::CharacterVector x) { return Rcpp::unique(x); } +// [[Rcpp::export]] +Rcpp::CharacterVector runit_sort_unique_ch(Rcpp::CharacterVector x, + bool decreasing = false) { + return Rcpp::sort_unique(x, decreasing); +} + // [[Rcpp::export]] IntegerVector runit_table( CharacterVector x){ return table( x ) ; diff --git a/inst/unitTests/cpp/support.cpp b/inst/tinytest/cpp/support.cpp similarity index 100% rename from inst/unitTests/cpp/support.cpp rename to inst/tinytest/cpp/support.cpp diff --git a/inst/unitTests/cpp/table.cpp b/inst/tinytest/cpp/table.cpp similarity index 100% rename from inst/unitTests/cpp/table.cpp rename to inst/tinytest/cpp/table.cpp diff --git a/inst/unitTests/cpp/wrap.cpp b/inst/tinytest/cpp/wrap.cpp similarity index 91% rename from inst/unitTests/cpp/wrap.cpp rename to inst/tinytest/cpp/wrap.cpp index 1f42f62d5..eefd5c2d9 100644 --- a/inst/unitTests/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/unitTests/cpp/wstring.cpp b/inst/tinytest/cpp/wstring.cpp similarity index 100% rename from inst/unitTests/cpp/wstring.cpp rename to inst/tinytest/cpp/wstring.cpp diff --git a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1.diff.gz b/inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1.diff.gz similarity index 100% rename from inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1.diff.gz rename to inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1.diff.gz diff --git a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1.dsc b/inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1.dsc similarity index 100% rename from inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1.dsc rename to inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1.dsc diff --git a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_amd64.changes b/inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_amd64.changes similarity index 100% rename from inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_amd64.changes rename to inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_amd64.changes diff --git a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_amd64.deb b/inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_amd64.deb similarity index 100% rename from inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_amd64.deb rename to inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_amd64.deb diff --git a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_i386.changes b/inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_i386.changes similarity index 100% rename from inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_i386.changes rename to inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_i386.changes diff --git a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_i386.deb b/inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_i386.deb similarity index 100% rename from inst/unitTests/src/r-cran-testrcpppackage_0.1.0-1_i386.deb rename to inst/tinytest/src/r-cran-testrcpppackage_0.1.0-1_i386.deb diff --git a/inst/tinytest/testRcppAttributePackage/DESCRIPTION b/inst/tinytest/testRcppAttributePackage/DESCRIPTION new file mode 100644 index 000000000..5c9a88427 --- /dev/null +++ b/inst/tinytest/testRcppAttributePackage/DESCRIPTION @@ -0,0 +1,11 @@ +Package: testRcppAttributePackage +Type: Package +Title: Tests the signature attribute and other attributes in package compilation +Version: 1.0 +Date: 2021-10-09 +Author: Travers Ching +Maintainer: Dirk Eddelbuettel +Description: Small test package part of Rcpp unit tests +License: GPL (>= 2) +Imports: Rcpp (>= 1.0.7) +LinkingTo: Rcpp diff --git a/inst/tinytest/testRcppAttributePackage/NAMESPACE b/inst/tinytest/testRcppAttributePackage/NAMESPACE new file mode 100644 index 000000000..7d63c4e69 --- /dev/null +++ b/inst/tinytest/testRcppAttributePackage/NAMESPACE @@ -0,0 +1,3 @@ +useDynLib(testRcppAttributePackage, .registration=TRUE) +importFrom(Rcpp, evalCpp) +exportPattern("^[[:alpha:]]+") diff --git a/inst/tinytest/testRcppAttributePackage/src/rcpp_test.cpp b/inst/tinytest/testRcppAttributePackage/src/rcpp_test.cpp new file mode 100644 index 000000000..465c78889 --- /dev/null +++ b/inst/tinytest/testRcppAttributePackage/src/rcpp_test.cpp @@ -0,0 +1,95 @@ +#include +using namespace Rcpp; + +// [[Rcpp::interfaces(r, cpp)]] + +// [[Rcpp::export]] +List test_no_attributes(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + +// [[Rcpp::export( signature = {x = list("{A}", "B"), verbose = getOption("verbose")} )]] +List test_signature(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + +// [[Rcpp::export( rng = false, signature = {x = list("{A}", "B"), verbose = getOption("verbose")}, invisible = true )]] +List test_rng_false_signature_invisible_true(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + +// [[Rcpp::export( rng = false )]] +List test_rng_false(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + +// [[Rcpp::export( rng = true )]] +List test_rng_true(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + +// [[Rcpp::export( signature = {x = list("{A}", "B"), verbose = getOption("verbose")}, rng = true )]] +List test_rng_true_signature(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + + +// [[Rcpp::export( invisible = true, rng = true )]] +List test_invisible_true_rng_true(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + +// [[Rcpp::export( invisible = true )]] +List test_invisible_true(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} + +// [[Rcpp::export( invisible = true, signature = {x = list("{A}", "B"), verbose = getOption("verbose")} )]] +List test_invisible_true_signature(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +} \ No newline at end of file diff --git a/inst/unitTests/testRcppClass/DESCRIPTION b/inst/tinytest/testRcppClass/DESCRIPTION similarity index 100% rename from inst/unitTests/testRcppClass/DESCRIPTION rename to inst/tinytest/testRcppClass/DESCRIPTION diff --git a/inst/unitTests/testRcppClass/NAMESPACE b/inst/tinytest/testRcppClass/NAMESPACE similarity index 100% rename from inst/unitTests/testRcppClass/NAMESPACE rename to inst/tinytest/testRcppClass/NAMESPACE diff --git a/inst/unitTests/testRcppClass/R/load.R b/inst/tinytest/testRcppClass/R/load.R similarity index 100% rename from inst/unitTests/testRcppClass/R/load.R rename to inst/tinytest/testRcppClass/R/load.R diff --git a/inst/unitTests/testRcppClass/R/rcpp_hello_world.R b/inst/tinytest/testRcppClass/R/rcpp_hello_world.R similarity index 100% rename from inst/unitTests/testRcppClass/R/rcpp_hello_world.R rename to inst/tinytest/testRcppClass/R/rcpp_hello_world.R diff --git a/inst/unitTests/testRcppClass/man/Rcpp_class_examples.Rd b/inst/tinytest/testRcppClass/man/Rcpp_class_examples.Rd similarity index 100% rename from inst/unitTests/testRcppClass/man/Rcpp_class_examples.Rd rename to inst/tinytest/testRcppClass/man/Rcpp_class_examples.Rd diff --git a/inst/unitTests/testRcppClass/man/rcpp_hello_world.Rd b/inst/tinytest/testRcppClass/man/rcpp_hello_world.Rd similarity index 100% rename from inst/unitTests/testRcppClass/man/rcpp_hello_world.Rd rename to inst/tinytest/testRcppClass/man/rcpp_hello_world.Rd diff --git a/inst/unitTests/testRcppClass/man/testRcppClass-package.Rd b/inst/tinytest/testRcppClass/man/testRcppClass-package.Rd similarity index 100% rename from inst/unitTests/testRcppClass/man/testRcppClass-package.Rd rename to inst/tinytest/testRcppClass/man/testRcppClass-package.Rd diff --git a/inst/unitTests/testRcppClass/src/Num.cpp b/inst/tinytest/testRcppClass/src/Num.cpp similarity index 100% rename from inst/unitTests/testRcppClass/src/Num.cpp rename to inst/tinytest/testRcppClass/src/Num.cpp diff --git a/inst/unitTests/testRcppClass/src/init.c b/inst/tinytest/testRcppClass/src/init.c similarity index 78% rename from inst/unitTests/testRcppClass/src/init.c rename to inst/tinytest/testRcppClass/src/init.c index 6dc74eb23..7e7715d0e 100644 --- a/inst/unitTests/testRcppClass/src/init.c +++ b/inst/tinytest/testRcppClass/src/init.c @@ -3,15 +3,15 @@ #include // for NULL #include -/* FIXME: +/* FIXME: Check these declarations against the C/Fortran source code. */ /* .Call calls */ -extern SEXP rcpp_hello_world_cpp(); -extern SEXP _rcpp_module_boot_NumEx(); -extern SEXP _rcpp_module_boot_RcppClassModule(); -extern SEXP _rcpp_module_boot_stdVector(); +extern SEXP rcpp_hello_world_cpp(void); +extern SEXP _rcpp_module_boot_NumEx(void); +extern SEXP _rcpp_module_boot_RcppClassModule(void); +extern SEXP _rcpp_module_boot_stdVector(void); static const R_CallMethodDef CallEntries[] = { {"rcpp_hello_world_cpp", (DL_FUNC) &rcpp_hello_world_cpp, 0}, diff --git a/inst/unitTests/testRcppClass/src/rcpp_hello_world.cpp b/inst/tinytest/testRcppClass/src/rcpp_hello_world.cpp similarity index 100% rename from inst/unitTests/testRcppClass/src/rcpp_hello_world.cpp rename to inst/tinytest/testRcppClass/src/rcpp_hello_world.cpp diff --git a/inst/unitTests/testRcppClass/src/rcpp_hello_world.h b/inst/tinytest/testRcppClass/src/rcpp_hello_world.h similarity index 100% rename from inst/unitTests/testRcppClass/src/rcpp_hello_world.h rename to inst/tinytest/testRcppClass/src/rcpp_hello_world.h diff --git a/inst/unitTests/testRcppClass/src/rcpp_module.cpp b/inst/tinytest/testRcppClass/src/rcpp_module.cpp similarity index 100% rename from inst/unitTests/testRcppClass/src/rcpp_module.cpp rename to inst/tinytest/testRcppClass/src/rcpp_module.cpp diff --git a/inst/unitTests/testRcppClass/src/stdVector.cpp b/inst/tinytest/testRcppClass/src/stdVector.cpp similarity index 100% rename from inst/unitTests/testRcppClass/src/stdVector.cpp rename to inst/tinytest/testRcppClass/src/stdVector.cpp diff --git a/inst/unitTests/testRcppClass/tests/classes.R b/inst/tinytest/testRcppClass/tests/classes.R similarity index 100% rename from inst/unitTests/testRcppClass/tests/classes.R rename to inst/tinytest/testRcppClass/tests/classes.R diff --git a/inst/unitTests/testRcppInterfaceExporter/DESCRIPTION b/inst/tinytest/testRcppInterfaceExporter/DESCRIPTION similarity index 100% rename from inst/unitTests/testRcppInterfaceExporter/DESCRIPTION rename to inst/tinytest/testRcppInterfaceExporter/DESCRIPTION diff --git a/inst/unitTests/testRcppInterfaceExporter/NAMESPACE b/inst/tinytest/testRcppInterfaceExporter/NAMESPACE similarity index 100% rename from inst/unitTests/testRcppInterfaceExporter/NAMESPACE rename to inst/tinytest/testRcppInterfaceExporter/NAMESPACE diff --git a/inst/tinytest/testRcppInterfaceExporter/R/RcppExports.R b/inst/tinytest/testRcppInterfaceExporter/R/RcppExports.R new file mode 100644 index 000000000..a9f09aff4 --- /dev/null +++ b/inst/tinytest/testRcppInterfaceExporter/R/RcppExports.R @@ -0,0 +1,12 @@ +# Generated by using Rcpp::compileAttributes() -> do not edit by hand +# Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#' @export +test_cpp_interface <- function(x, fast = FALSE) { + .Call(`_testRcppInterfaceExporter_test_cpp_interface`, x, fast) +} + +# Register entry points for exported C++ functions +methods::setLoadAction(function(ns) { + .Call(`_testRcppInterfaceExporter_RcppExport_registerCCallable`) +}) diff --git a/inst/unitTests/testRcppInterfaceExporter/R/exporter.R b/inst/tinytest/testRcppInterfaceExporter/R/exporter.R similarity index 100% rename from inst/unitTests/testRcppInterfaceExporter/R/exporter.R rename to inst/tinytest/testRcppInterfaceExporter/R/exporter.R diff --git a/inst/tinytest/testRcppInterfaceExporter/inst/include/testRcppInterfaceExporter.h b/inst/tinytest/testRcppInterfaceExporter/inst/include/testRcppInterfaceExporter.h new file mode 100644 index 000000000..c040db966 --- /dev/null +++ b/inst/tinytest/testRcppInterfaceExporter/inst/include/testRcppInterfaceExporter.h @@ -0,0 +1,9 @@ +// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#ifndef RCPP_testRcppInterfaceExporter_H_GEN_ +#define RCPP_testRcppInterfaceExporter_H_GEN_ + +#include "testRcppInterfaceExporter_RcppExports.h" + +#endif // RCPP_testRcppInterfaceExporter_H_GEN_ diff --git a/inst/tinytest/testRcppInterfaceExporter/inst/include/testRcppInterfaceExporter_RcppExports.h b/inst/tinytest/testRcppInterfaceExporter/inst/include/testRcppInterfaceExporter_RcppExports.h new file mode 100644 index 000000000..d6faec64b --- /dev/null +++ b/inst/tinytest/testRcppInterfaceExporter/inst/include/testRcppInterfaceExporter_RcppExports.h @@ -0,0 +1,50 @@ +// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#ifndef RCPP_testRcppInterfaceExporter_RCPPEXPORTS_H_GEN_ +#define RCPP_testRcppInterfaceExporter_RCPPEXPORTS_H_GEN_ + +#include + +namespace testRcppInterfaceExporter { + + using namespace Rcpp; + + namespace { + void validateSignature(const char* sig) { + Rcpp::Function require = Rcpp::Environment::base_env()["require"]; + require("testRcppInterfaceExporter", Rcpp::Named("quietly") = true); + typedef int(*Ptr_validate)(const char*); + static Ptr_validate p_validate = (Ptr_validate) + R_GetCCallable("testRcppInterfaceExporter", "_testRcppInterfaceExporter_RcppExport_validate"); + if (!p_validate(sig)) { + throw Rcpp::function_not_exported( + "C++ function with signature '" + std::string(sig) + "' not found in testRcppInterfaceExporter"); + } + } + } + + inline SEXP test_cpp_interface(SEXP x, bool fast = false) { + typedef SEXP(*Ptr_test_cpp_interface)(SEXP,SEXP); + static Ptr_test_cpp_interface p_test_cpp_interface = NULL; + if (p_test_cpp_interface == NULL) { + validateSignature("SEXP(*test_cpp_interface)(SEXP,bool)"); + p_test_cpp_interface = (Ptr_test_cpp_interface)R_GetCCallable("testRcppInterfaceExporter", "_testRcppInterfaceExporter_test_cpp_interface"); + } + RObject rcpp_result_gen; + { + RNGScope RCPP_rngScope_gen; + rcpp_result_gen = p_test_cpp_interface(Shield(Rcpp::wrap(x)), Shield(Rcpp::wrap(fast))); + } + if (rcpp_result_gen.inherits("interrupted-error")) + throw Rcpp::internal::InterruptedException(); + if (Rcpp::internal::isLongjumpSentinel(rcpp_result_gen)) + throw Rcpp::LongjumpException(rcpp_result_gen); + if (rcpp_result_gen.inherits("try-error")) + throw Rcpp::exception(Rcpp::as(rcpp_result_gen).c_str()); + return Rcpp::as(rcpp_result_gen); + } + +} + +#endif // RCPP_testRcppInterfaceExporter_RCPPEXPORTS_H_GEN_ diff --git a/inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp b/inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp new file mode 100644 index 000000000..4b018f29f --- /dev/null +++ b/inst/tinytest/testRcppInterfaceExporter/src/RcppExports.cpp @@ -0,0 +1,77 @@ +// Generated by using Rcpp::compileAttributes() -> do not edit by hand +// Generator token: 10BE3573-1514-4C36-9D1C-5A225CD40393 + +#include "../inst/include/testRcppInterfaceExporter.h" +#include +#include +#include + +using namespace Rcpp; + +#ifdef RCPP_USE_GLOBAL_ROSTREAM +Rcpp::Rostream& Rcpp::Rcout = Rcpp::Rcpp_cout_get(); +Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get(); +#endif + +// test_cpp_interface +SEXP test_cpp_interface(SEXP x, bool fast); +static SEXP _testRcppInterfaceExporter_test_cpp_interface_try(SEXP xSEXP, SEXP fastSEXP) { +BEGIN_RCPP + Rcpp::RObject rcpp_result_gen; + Rcpp::traits::input_parameter< SEXP >::type x(xSEXP); + Rcpp::traits::input_parameter< bool >::type fast(fastSEXP); + rcpp_result_gen = Rcpp::wrap(test_cpp_interface(x, fast)); + return rcpp_result_gen; +END_RCPP_RETURN_ERROR +} +RcppExport SEXP _testRcppInterfaceExporter_test_cpp_interface(SEXP xSEXP, SEXP fastSEXP) { + SEXP rcpp_result_gen; + { + Rcpp::RNGScope rcpp_rngScope_gen; + rcpp_result_gen = PROTECT(_testRcppInterfaceExporter_test_cpp_interface_try(xSEXP, fastSEXP)); + } + Rboolean rcpp_isInterrupt_gen = Rf_inherits(rcpp_result_gen, "interrupted-error"); + if (rcpp_isInterrupt_gen) { + UNPROTECT(1); + Rf_onintr(); + } + bool rcpp_isLongjump_gen = Rcpp::internal::isLongjumpSentinel(rcpp_result_gen); + if (rcpp_isLongjump_gen) { + Rcpp::internal::resumeJump(rcpp_result_gen); + } + Rboolean rcpp_isError_gen = Rf_inherits(rcpp_result_gen, "try-error"); + if (rcpp_isError_gen) { + SEXP rcpp_msgSEXP_gen = Rf_asChar(rcpp_result_gen); + UNPROTECT(1); + (Rf_error)("%s", CHAR(rcpp_msgSEXP_gen)); + } + UNPROTECT(1); + return rcpp_result_gen; +} + +// validate (ensure exported C++ functions exist before calling them) +static int _testRcppInterfaceExporter_RcppExport_validate(const char* sig) { + static std::set signatures; + if (signatures.empty()) { + signatures.insert("SEXP(*test_cpp_interface)(SEXP,bool)"); + } + return signatures.find(sig) != signatures.end(); +} + +// registerCCallable (register entry points for exported C++ functions) +RcppExport SEXP _testRcppInterfaceExporter_RcppExport_registerCCallable() { + R_RegisterCCallable("testRcppInterfaceExporter", "_testRcppInterfaceExporter_test_cpp_interface", (DL_FUNC)_testRcppInterfaceExporter_test_cpp_interface_try); + R_RegisterCCallable("testRcppInterfaceExporter", "_testRcppInterfaceExporter_RcppExport_validate", (DL_FUNC)_testRcppInterfaceExporter_RcppExport_validate); + return R_NilValue; +} + +static const R_CallMethodDef CallEntries[] = { + {"_testRcppInterfaceExporter_test_cpp_interface", (DL_FUNC) &_testRcppInterfaceExporter_test_cpp_interface, 2}, + {"_testRcppInterfaceExporter_RcppExport_registerCCallable", (DL_FUNC) &_testRcppInterfaceExporter_RcppExport_registerCCallable, 0}, + {NULL, NULL, 0} +}; + +RcppExport void R_init_testRcppInterfaceExporter(DllInfo *dll) { + R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); + R_useDynamicSymbols(dll, FALSE); +} diff --git a/inst/unitTests/testRcppInterfaceExporter/src/exporter.cpp b/inst/tinytest/testRcppInterfaceExporter/src/exporter.cpp similarity index 100% rename from inst/unitTests/testRcppInterfaceExporter/src/exporter.cpp rename to inst/tinytest/testRcppInterfaceExporter/src/exporter.cpp diff --git a/inst/unitTests/testRcppInterfaceExporter/src/unwound.h b/inst/tinytest/testRcppInterfaceExporter/src/unwound.h similarity index 100% rename from inst/unitTests/testRcppInterfaceExporter/src/unwound.h rename to inst/tinytest/testRcppInterfaceExporter/src/unwound.h diff --git a/inst/unitTests/testRcppInterfaceUser/DESCRIPTION b/inst/tinytest/testRcppInterfaceUser/DESCRIPTION similarity index 100% rename from inst/unitTests/testRcppInterfaceUser/DESCRIPTION rename to inst/tinytest/testRcppInterfaceUser/DESCRIPTION diff --git a/inst/unitTests/testRcppInterfaceUser/NAMESPACE b/inst/tinytest/testRcppInterfaceUser/NAMESPACE similarity index 100% rename from inst/unitTests/testRcppInterfaceUser/NAMESPACE rename to inst/tinytest/testRcppInterfaceUser/NAMESPACE diff --git a/inst/unitTests/testRcppInterfaceUser/R/user.R b/inst/tinytest/testRcppInterfaceUser/R/user.R similarity index 100% rename from inst/unitTests/testRcppInterfaceUser/R/user.R rename to inst/tinytest/testRcppInterfaceUser/R/user.R diff --git a/inst/unitTests/testRcppInterfaceExporter/src/config.h b/inst/tinytest/testRcppInterfaceUser/src/config.h similarity index 100% rename from inst/unitTests/testRcppInterfaceExporter/src/config.h rename to inst/tinytest/testRcppInterfaceUser/src/config.h diff --git a/inst/unitTests/testRcppInterfaceUser/src/unwound.h b/inst/tinytest/testRcppInterfaceUser/src/unwound.h similarity index 100% rename from inst/unitTests/testRcppInterfaceUser/src/unwound.h rename to inst/tinytest/testRcppInterfaceUser/src/unwound.h diff --git a/inst/unitTests/testRcppInterfaceUser/src/user.cpp b/inst/tinytest/testRcppInterfaceUser/src/user.cpp similarity index 100% rename from inst/unitTests/testRcppInterfaceUser/src/user.cpp rename to inst/tinytest/testRcppInterfaceUser/src/user.cpp diff --git a/inst/unitTests/testRcppInterfaceUser/tests/tests.R b/inst/tinytest/testRcppInterfaceUser/tests/tests.R similarity index 84% rename from inst/unitTests/testRcppInterfaceUser/tests/tests.R rename to inst/tinytest/testRcppInterfaceUser/tests/tests.R index effb2e482..f5885bd98 100644 --- a/inst/unitTests/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/unitTests/testRcppModule/DESCRIPTION b/inst/tinytest/testRcppModule/DESCRIPTION similarity index 100% rename from inst/unitTests/testRcppModule/DESCRIPTION rename to inst/tinytest/testRcppModule/DESCRIPTION diff --git a/inst/unitTests/testRcppModule/NAMESPACE b/inst/tinytest/testRcppModule/NAMESPACE similarity index 100% rename from inst/unitTests/testRcppModule/NAMESPACE rename to inst/tinytest/testRcppModule/NAMESPACE diff --git a/inst/unitTests/testRcppModule/R/rcpp_hello_world.R b/inst/tinytest/testRcppModule/R/rcpp_hello_world.R similarity index 100% rename from inst/unitTests/testRcppModule/R/rcpp_hello_world.R rename to inst/tinytest/testRcppModule/R/rcpp_hello_world.R diff --git a/inst/unitTests/testRcppModule/R/zzz.R b/inst/tinytest/testRcppModule/R/zzz.R similarity index 52% rename from inst/unitTests/testRcppModule/R/zzz.R rename to inst/tinytest/testRcppModule/R/zzz.R index f23b84272..e26fbae91 100644 --- a/inst/unitTests/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/unitTests/testRcppModule/man/Rcpp_modules_examples.Rd b/inst/tinytest/testRcppModule/man/Rcpp_modules_examples.Rd similarity index 100% rename from inst/unitTests/testRcppModule/man/Rcpp_modules_examples.Rd rename to inst/tinytest/testRcppModule/man/Rcpp_modules_examples.Rd diff --git a/inst/unitTests/testRcppModule/man/rcpp_hello_world.Rd b/inst/tinytest/testRcppModule/man/rcpp_hello_world.Rd similarity index 100% rename from inst/unitTests/testRcppModule/man/rcpp_hello_world.Rd rename to inst/tinytest/testRcppModule/man/rcpp_hello_world.Rd diff --git a/inst/unitTests/testRcppModule/man/testRcppModule-package.Rd b/inst/tinytest/testRcppModule/man/testRcppModule-package.Rd similarity index 100% rename from inst/unitTests/testRcppModule/man/testRcppModule-package.Rd rename to inst/tinytest/testRcppModule/man/testRcppModule-package.Rd diff --git a/inst/unitTests/testRcppModule/src/Num.cpp b/inst/tinytest/testRcppModule/src/Num.cpp similarity index 100% rename from inst/unitTests/testRcppModule/src/Num.cpp rename to inst/tinytest/testRcppModule/src/Num.cpp diff --git a/inst/unitTests/testRcppModule/src/init.c b/inst/tinytest/testRcppModule/src/init.c similarity index 100% rename from inst/unitTests/testRcppModule/src/init.c rename to inst/tinytest/testRcppModule/src/init.c diff --git a/inst/unitTests/testRcppModule/src/rcpp_hello_world.cpp b/inst/tinytest/testRcppModule/src/rcpp_hello_world.cpp similarity index 100% rename from inst/unitTests/testRcppModule/src/rcpp_hello_world.cpp rename to inst/tinytest/testRcppModule/src/rcpp_hello_world.cpp diff --git a/inst/unitTests/testRcppModule/src/rcpp_hello_world.h b/inst/tinytest/testRcppModule/src/rcpp_hello_world.h similarity index 100% rename from inst/unitTests/testRcppModule/src/rcpp_hello_world.h rename to inst/tinytest/testRcppModule/src/rcpp_hello_world.h diff --git a/inst/unitTests/testRcppModule/src/rcpp_module.cpp b/inst/tinytest/testRcppModule/src/rcpp_module.cpp similarity index 100% rename from inst/unitTests/testRcppModule/src/rcpp_module.cpp rename to inst/tinytest/testRcppModule/src/rcpp_module.cpp diff --git a/inst/unitTests/testRcppModule/src/stdVector.cpp b/inst/tinytest/testRcppModule/src/stdVector.cpp similarity index 100% rename from inst/unitTests/testRcppModule/src/stdVector.cpp rename to inst/tinytest/testRcppModule/src/stdVector.cpp diff --git a/inst/unitTests/testRcppModule/tests/modules.R b/inst/tinytest/testRcppModule/tests/modules.R similarity index 100% rename from inst/unitTests/testRcppModule/tests/modules.R rename to inst/tinytest/testRcppModule/tests/modules.R diff --git a/inst/unitTests/testRcppPackage/DESCRIPTION b/inst/tinytest/testRcppPackage/DESCRIPTION similarity index 100% rename from inst/unitTests/testRcppPackage/DESCRIPTION rename to inst/tinytest/testRcppPackage/DESCRIPTION diff --git a/inst/unitTests/testRcppPackage/NAMESPACE b/inst/tinytest/testRcppPackage/NAMESPACE similarity index 100% rename from inst/unitTests/testRcppPackage/NAMESPACE rename to inst/tinytest/testRcppPackage/NAMESPACE diff --git a/inst/unitTests/testRcppPackage/R/rcpp_hello_world.R b/inst/tinytest/testRcppPackage/R/rcpp_hello_world.R similarity index 100% rename from inst/unitTests/testRcppPackage/R/rcpp_hello_world.R rename to inst/tinytest/testRcppPackage/R/rcpp_hello_world.R diff --git a/inst/unitTests/testRcppPackage/debian/changelog b/inst/tinytest/testRcppPackage/debian/changelog similarity index 100% rename from inst/unitTests/testRcppPackage/debian/changelog rename to inst/tinytest/testRcppPackage/debian/changelog diff --git a/inst/unitTests/testRcppPackage/debian/compat b/inst/tinytest/testRcppPackage/debian/compat similarity index 100% rename from inst/unitTests/testRcppPackage/debian/compat rename to inst/tinytest/testRcppPackage/debian/compat diff --git a/inst/unitTests/testRcppPackage/debian/control b/inst/tinytest/testRcppPackage/debian/control similarity index 100% rename from inst/unitTests/testRcppPackage/debian/control rename to inst/tinytest/testRcppPackage/debian/control diff --git a/inst/unitTests/testRcppPackage/debian/copyright b/inst/tinytest/testRcppPackage/debian/copyright similarity index 100% rename from inst/unitTests/testRcppPackage/debian/copyright rename to inst/tinytest/testRcppPackage/debian/copyright diff --git a/inst/unitTests/testRcppPackage/debian/rules b/inst/tinytest/testRcppPackage/debian/rules similarity index 100% rename from inst/unitTests/testRcppPackage/debian/rules rename to inst/tinytest/testRcppPackage/debian/rules diff --git a/inst/unitTests/testRcppPackage/debian/source/format b/inst/tinytest/testRcppPackage/debian/source/format similarity index 100% rename from inst/unitTests/testRcppPackage/debian/source/format rename to inst/tinytest/testRcppPackage/debian/source/format diff --git a/inst/unitTests/testRcppPackage/man/testRcppPackage-package.Rd b/inst/tinytest/testRcppPackage/man/testRcppPackage-package.Rd similarity index 100% rename from inst/unitTests/testRcppPackage/man/testRcppPackage-package.Rd rename to inst/tinytest/testRcppPackage/man/testRcppPackage-package.Rd diff --git a/inst/unitTests/testRcppPackage/src/rcpp_hello_world.cpp b/inst/tinytest/testRcppPackage/src/rcpp_hello_world.cpp similarity index 100% rename from inst/unitTests/testRcppPackage/src/rcpp_hello_world.cpp rename to inst/tinytest/testRcppPackage/src/rcpp_hello_world.cpp diff --git a/inst/unitTests/testRcppPackage/src/rcpp_hello_world.h b/inst/tinytest/testRcppPackage/src/rcpp_hello_world.h similarity index 100% rename from inst/unitTests/testRcppPackage/src/rcpp_hello_world.h rename to inst/tinytest/testRcppPackage/src/rcpp_hello_world.h diff --git a/inst/tinytest/test_algorithm.R b/inst/tinytest/test_algorithm.R new file mode 100644 index 000000000..a0985473f --- /dev/null +++ b/inst/tinytest/test_algorithm.R @@ -0,0 +1,126 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/algorithm.cpp") + +# test.sum <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(sum(v), sumTest(v, 1, 5)) +v <- c(NA, 1.0, 2.0, 3.0, 4.0) +expect_equal(sum(v), sumTest(v, 1, 5)) + +# test.sum.nona <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(sum(v), sumTest_nona(v, 1, 5)) + +# test.prod <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(prod(v), prodTest(v, 1, 5)) +v <- c(NA, 1.0, 2.0, 3.0, 4.0) +expect_equal(prod(v), prodTest(v, 1, 5)) + +#test.prod.nona <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(prod(v), prodTest_nona(v, 1, 5)) + +#test.log <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(log(v), logTest(v)) +v <- c(NA, 1.0, 2.0, 3.0, 4.0) +expect_equal(log(v), logTest(v)) + +# test.exp <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(exp(v), expTest(v)) +v <- c(NA, 1.0, 2.0, 3.0, 4.0) +expect_equal(exp(v), expTest(v)) + +# test.sqrt <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(sqrt(v), sqrtTest(v)) +v <- c(NA, 1.0, 2.0, 3.0, 4.0) +expect_equal(sqrt(v), sqrtTest(v)) + +# test.min <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(min(v), minTest(v)) +v <- c(NA, 1.0, 2.0, 3.0, 4.0) +expect_equal(min(v), minTest(v)) + +# test.min.nona <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(min(v), minTest_nona(v)) + +# test.min.int <- function() { +v <- c(1, 2, 3, 4, 5) +expect_equal(min(v), minTest_int(v)) +v <- c(NA, 1, 2, 3, 4) +expect_equal(min(v), minTest_int(v)) + +# test.min.int.nona <- function() { +v <- c(1, 2, 3, 4, 5) +expect_equal(min(v), minTest_int_nona(v)) + +# test.max <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(max(v), maxTest(v)) +v <- c(NA, 1.0, 2.0, 3.0, 4.0) +expect_equal(max(v), maxTest(v)) + +# test.max.nona <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(max(v), maxTest_nona(v)) + +# test.max.int <- function() { +v <- c(1, 2, 3, 4, 5) +expect_equal(max(v), maxTest_int(v)) +v <- c(NA, 1, 2, 3, 4) +expect_equal(max(v), maxTest_int(v)) + +# test.max.int.nona <- function() { +v <- c(1, 2, 3, 4, 5) +expect_equal(max(v), maxTest_int_nona(v)) + +# test.mean <- function() { +v <- c(1.0, 2.0, 3.0, 4.0, 5.0) +expect_equal(mean(v), meanTest(v)) +v <- c(1.0, 2.0, 3.0, 4.0, NA) +expect_equal(mean(v), meanTest(v)) +v <- c(1.0, 2.0, 3.0, 4.0, NaN) +expect_equal(mean(v), meanTest(v)) +v <- c(1.0, 2.0, 3.0, 4.0, 1.0/0.0) +expect_equal(mean(v), meanTest(v)) +v <- c(1.0, 2.0, 3.0, 4.0, -1.0/0.0) +expect_equal(mean(v), meanTest(v)) +v <- c(1.0, 2.0, 1.0/0.0, NA, NaN) +expect_equal(mean(v), meanTest(v)) +v <- c(1.0, 2.0, 1.0/0.0, NaN, NA) + +# test.mean.int <- function() { +v <- c(1, 2, 3, 4, 5) +expect_equal(mean(v), meanTest_int(v)) +v <- c(1, 2, 3, 4, NA) +expect_equal(mean(v), meanTest_int(v)) + +#test.mean.logical <- function() { +v <- c(TRUE, FALSE, FALSE) +expect_equal(mean(v), meanTest_logical(v)) +v <- c(TRUE, FALSE, FALSE, NA) +expect_equal(mean(v), meanTest_logical(v)) diff --git a/inst/tinytest/test_as.R b/inst/tinytest/test_as.R new file mode 100644 index 000000000..7c96df286 --- /dev/null +++ b/inst/tinytest/test_as.R @@ -0,0 +1,81 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/as.cpp") + +# test.as.int <- function(){ +expect_equal( as_int(10), 10L, info = "as( REALSXP ) " ) +expect_equal( as_int(10L), 10L, info = "as( INTSXP ) " ) +expect_equal( as_int(as.raw(10L)), 10L, info = "as( RAWSXP ) " ) +expect_equal( as_int(TRUE), 1L, info = "as( LGLSXP ) " ) + +# test.as.double <- function(){ +expect_equal( as_double(10), 10.0, info = "as( REALSXP ) " ) +expect_equal( as_double(10L), 10.0, info = "as( INTSXP ) " ) +expect_equal( as_double(as.raw(10L)), 10.0, info = "as( RAWSXP ) " ) +expect_equal( as_double(TRUE), 1.0, info = "as( LGLSXP ) " ) + +# test.as.raw <- function(){ +expect_equal( as_raw(10), as.raw(10), info = "as( REALSXP ) " ) +expect_equal( as_raw(10L), as.raw(10), info = "as( INTSXP ) " ) +expect_equal( as_raw(as.raw(10L)), as.raw(10), info = "as( RAWSXP ) " ) +expect_equal( as_raw(TRUE), as.raw(1), info = "as( LGLSXP ) " ) + +# test.as.bool <- function(){ +expect_equal( as_bool(10), as.logical(10), info = "as( REALSXP ) " ) +expect_equal( as_bool(10L), as.logical(10), info = "as( INTSXP ) " ) +expect_equal( as_bool(as.raw(10L)), as.logical(10), info = "as( RAWSXP ) " ) +expect_equal( as_bool(TRUE), as.logical(1), info = "as( LGLSXP ) " ) + +#test.as.string <- function(){ +expect_equal( as_string("foo"), "foo", info = "as( STRSXP ) " ) + +# test.as.vector.int <- function(){ +expect_equal( as_vector_int(1:10), 1:10 , info = "as>( INTSXP ) " ) +expect_equal( as_vector_int(as.numeric(1:10)), 1:10 , info = "as>( REALSXP ) " ) +expect_equal( as_vector_int(as.raw(1:10)), 1:10 , info = "as>( RAWSXP ) " ) +expect_equal( as_vector_int(c(TRUE,FALSE)), 1:0 , info = "as>( LGLSXP ) " ) + +# test.as.vector.double <- function(){ +expect_equal( as_vector_double(1:10), as.numeric(1:10) , info = "as>( INTSXP ) " ) +expect_equal( as_vector_double(as.numeric(1:10)), as.numeric(1:10) , info = "as>( REALSXP ) " ) +expect_equal( as_vector_double(as.raw(1:10)), as.numeric(1:10), info = "as>( RAWSXP ) " ) +expect_equal( as_vector_double(c(TRUE,FALSE)), c(1.0, 0.0) , info = "as>( LGLSXP ) " ) + +# test.as.vector.raw <- function(){ +expect_equal( as_vector_raw(1:10), as.raw(1:10) , info = "as>( INTSXP ) " ) +expect_equal( as_vector_raw(as.numeric(1:10)), as.raw(1:10) , info = "as>( REALSXP ) " ) +expect_equal( as_vector_raw(as.raw(1:10)), as.raw(1:10) , info = "as>( RAWSXP ) " ) +expect_equal( as_vector_raw(c(TRUE,FALSE)), as.raw(1:0) , info = "as>( LGLSXP ) " ) + +# test.as.vector.bool <- function(){ +expect_equal( as_vector_bool(0:10), as.logical(0:10) , info = "as>( INTSXP ) " ) +expect_equal( as_vector_bool(as.numeric(0:10)), as.logical(0:10) , info = "as>( REALSXP ) " ) +expect_equal( as_vector_bool(as.raw(0:10)), as.logical(0:10) , info = "as>( RAWSXP ) " ) +expect_equal( as_vector_bool(c(TRUE,FALSE)), as.logical(1:0) , info = "as>( LGLSXP ) " ) + +# test.as.vector.string <- function(){ +expect_equal( as_vector_string(letters), letters , info = "as>( STRSXP ) " ) + +# test.as.deque.int <- function(){ +expect_equal( as_deque_int(1:10), 1:10 , info = "as>( INTSXP ) " ) + +# test.as.list.int <- function(){ +expect_equal( as_list_int(1:10), 1:10 , info = "as>( INTSXP ) " ) diff --git a/inst/tinytest/test_attribute_package.R b/inst/tinytest/test_attribute_package.R new file mode 100644 index 000000000..92671acaf --- /dev/null +++ b/inst/tinytest/test_attribute_package.R @@ -0,0 +1,180 @@ +## Copyright (C) 2010 - 2020 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2021 Dirk Eddelbuettel, Romain Francois and Travers Ching +## +## 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 . + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") + +td <- tempfile() +cwd <- getwd() +dir.create(td) +pkg <- "testRcppAttributePackage" +file.copy(pkg, td, recursive = TRUE) # simpler direct path thanks to tinytest +setwd(td) +on.exit( { setwd(cwd); unlink(td, recursive = TRUE) } ) +R <- shQuote(file.path( R.home(component = "bin"), "R")) +Rcpp::compileAttributes(pkg) +cmd <- paste(R, "CMD build", pkg) +invisible(system(cmd, intern=TRUE)) +dir.create("templib") +pkgfile <- paste0(pkg, "_1.0.tar.gz") +install.packages(pkgfile, "templib", repos = NULL, type = "source") +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_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_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)) +expect_equal(test_invisible_true(list("{A}"), FALSE),list("{A}", FALSE)) +expect_equal(test_invisible_true_signature(),list("{A}", TRUE)) +options(verbose=FALSE) + +# Test inline + +# test 0 +# This example should just run and not crash +Rcpp::sourceCpp(code=' +#include +using namespace Rcpp; +// [[Rcpp::export( rng = false, signature = {x=list("{A}", "B"), verbose = getOption("verbose")}, invisible = TRUE )]] +List test_inline(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +}') +expect_equal(test_inline(), list("{A}", FALSE)) +options(verbose=TRUE) +expect_equal(test_inline(), list("{A}", TRUE)) +options(verbose=FALSE) + +# test 1, from Enchufa2 +# The verbose argument should be replaced with FALSE +Rcpp::sourceCpp(code=' +#include +using namespace Rcpp; +// [[Rcpp::export( rng = false, signature = {x=list("{A}", "B"), verbose=FALSE} )]] +List test_inline(List x, bool verbose=true) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } +}') +expect_equal(test_inline(), list("{A}", FALSE)) + +# test 2, from Enchufa2 +# This second example should not compile because of missing parameter verbose +expect_error({ + Rcpp::sourceCpp(code=' + #include + using namespace Rcpp; + // [[Rcpp::export( rng = false, signature = {x=list("{A}", "B")} )]] + List test_inline(List x, bool verbose=true) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } + }') +}) + +# 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 +# invalid R code. There are some additional warnings due to the incorrect syntax +expect_warning({ + expect_error({ + Rcpp::sourceCpp(code=' + #include + using namespace Rcpp; + // [[Rcpp::export( rng = false, signature = {x=list("{A}", "B"), verbose=FALSE )]] + List test_inline(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } + }', verbose=T) + }) +}) + +# test 4, from Enchufa2 +# This 4th example is missing the end bracket and will not compile +expect_error({ + Rcpp::sourceCpp(code=' + #include + using namespace Rcpp; + // [[Rcpp::export( rng = false, signature = {x=list("A", "B"), verbose=FALSE )]] + List test_inline(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } + }') +}) + +# This 5th example has brackets but incorrect R syntax +expect_error({ + Rcpp::sourceCpp(code=' + #include + using namespace Rcpp; + // [[Rcpp::export( rng = false, signature = {x=list("A", ###, verbose=FALSE} )]] + List test_inline(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } + }') +}) + +# This 6th example is missing a parameter in the signature +expect_error({ + Rcpp::sourceCpp(code=' + #include + using namespace Rcpp; + // [[Rcpp::export( rng = false, signature = {x=list("A", "B")} )]] + List test_inline(List x, bool verbose) { + if(x.size() > 0) { + CharacterVector first_element = x[0]; + return List::create(first_element, verbose); + } else { + return List::create(verbose); + } + }') +}) + + +remove.packages(pkg, lib="templib") +unlink("templib", recursive = TRUE) +setwd(cwd) +unlink(pkgfile) diff --git a/inst/tinytest/test_attributes.R b/inst/tinytest/test_attributes.R new file mode 100644 index 000000000..91d0e7380 --- /dev/null +++ b/inst/tinytest/test_attributes.R @@ -0,0 +1,40 @@ + +## Copyright (C) 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/attributes.cpp") + +#test.attributes <- function() { +expect_equal(comments_test(), + "Start a C++ line comment with the characters \"//\"") + +expect_equal(parse_declaration_test(), + "Parse function declaration") + +expect_equal(parse_default_values_with_str_parenthesis(), + "Parse function header with parenthis inside default string values.") + +expect_equal(parse_default_values_with_chr_parenthesis(), + "Parse function header with parenthis inside default char values.") + +expect_equal(parse_default_values_with_chr_backslash(), + "Parse function header with backslash inside default char values.") + +## cf issue #1026 and pr #1027 +expect_error(cppFunction("bool foo() { return false; }", depends = "fakepkg")) diff --git a/inst/tinytest/test_binary_package.R b/inst/tinytest/test_binary_package.R new file mode 100644 index 000000000..15a5253c0 --- /dev/null +++ b/inst/tinytest/test_binary_package.R @@ -0,0 +1,61 @@ + +## Copyright (C) 2014 - 2019 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 . + +.onLinux <- .Platform$OS.type == "unix" && unname(Sys.info()["sysname"]) == "Linux" + +.onTravis <- Sys.getenv("TRAVIS") != "" + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +##test.binary.testRcppPackage <- function() { + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") +if (! .onLinux) exit_file("Only running this on Linux.'") +if (.onTravis) exit_file("Not running on Travis.") + +exit_file("Skipping for now as underlying binary needs to be updated.") + +debpkg <- "r-cran-testrcpppackage" +rpkg <- "testRcppPackage" + +## R calls it i686 or x86_64; Debian/Ubuntu call it i386 or amd64 +arch <- switch(unname(Sys.info()["machine"]), "i686"="i386", "x86_64"="amd64") + +## filename of pre-built -- easier with tinytest as bin/ is a subdir of current dir +debfile <- file.path("bin", arch, paste0(debpkg, "_0.1.0-1_", arch, ".deb")) + +if (! file.exists(debfile)) exit_file("Binary not found, skipping 'test_binary_package.R' tests") + +system(paste("sudo dpkg -i", debfile)) + +## R> testRcppPackage:::rcpp_hello_world() +## [[1]] +## [1] "foo" "bar" + +## [[2]] +## [1] 0 1 + +## R> + +require(rpkg, lib.loc = "/usr/lib/R/site-library", character.only = TRUE) +hello_world <- get("rcpp_hello_world", asNamespace(rpkg)) + +expect_equal(hello_world(), list(c("foo", "bar"), c(0.0, 1.0)), + msg = "code from binary package") + +system(paste("sudo dpkg --purge", debpkg)) diff --git a/inst/tinytest/test_client_package.R b/inst/tinytest/test_client_package.R new file mode 100644 index 000000000..48a213f6b --- /dev/null +++ b/inst/tinytest/test_client_package.R @@ -0,0 +1,50 @@ + +## Copyright (C) 2010 - 2019 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 . + +## This now (Dec 2011) appears to fail on Windows +.onWindows <- .Platform$OS.type == "windows" + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") +if (.onWindows) exit_file("Skipping on Windows.'") + +#.client.package <- function(pkg = "testRcppPackage") { +td <- tempfile() +cwd <- getwd() +dir.create(td) +pkg <- "testRcppPackage" +#file.copy(system.file("unitTests", pkg, package = "Rcpp"), td, recursive = TRUE) +file.copy(pkg, td, recursive = TRUE) # simpler direct path thanks to tinytest +setwd(td) +on.exit( { setwd(cwd); unlink(td, recursive = TRUE) } ) +R <- shQuote(file.path( R.home(component = "bin"), "R")) +cmd <- paste(R, "CMD build", pkg, " >/dev/null 2>&1") +system(cmd) +dir.create("templib") +pkgfile <- paste0(pkg, "_0.1.0.tar.gz") +install.packages(pkgfile, "templib", repos = NULL, type = "source") +require(pkg, lib.loc = "templib", character.only = TRUE) +hello_world <- get("rcpp_hello_world", asNamespace(pkg)) +expect_equal(hello_world(), list(c("foo", "bar"), c(0.0, 1.0)), + info = "code from client package") +expect_error(.Call("hello_world_ex", PACKAGE = pkg), info = "exception in client package") +remove.packages(pkg, lib="templib") +unlink("templib", recursive = TRUE) +setwd(cwd) +unlink(pkgfile) diff --git a/inst/tinytest/test_coerce.R b/inst/tinytest/test_coerce.R new file mode 100644 index 000000000..1c775d92d --- /dev/null +++ b/inst/tinytest/test_coerce.R @@ -0,0 +1,23 @@ + +## Copyright (C) 2022 Dirk Eddelbuettel 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/coerce.cpp") + +expect_equal(coerce_raw_to_string(0xaa), "aa") diff --git a/inst/tinytest/test_dataframe.R b/inst/tinytest/test_dataframe.R new file mode 100644 index 000000000..f9571cb1e --- /dev/null +++ b/inst/tinytest/test_dataframe.R @@ -0,0 +1,119 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/DataFrame.cpp") + +#test.DataFrame.FromSEXP <- function() { +DF <- data.frame(a=1:3, b=c("a","b","c")) +expect_equal( FromSEXP(DF), DF, info = "DataFrame pass-through") + +# test.DataFrame.index.byName <- function() { +DF <- data.frame(a=1:3, b=c("a","b","c")) +expect_equal( index_byName(DF, "a"), DF$a, info = "DataFrame column by name 'a'") +expect_equal( index_byName(DF, "b"), DF$b, info = "DataFrame column by name 'b'") + +# test.DataFrame.index.byPosition <- function() { +DF <- data.frame(a=1:3, b=c("a","b","c")) +expect_equal( index_byPosition(DF, 0), DF$a, info = "DataFrame column by position 0") +expect_equal( index_byPosition(DF, 1), DF$b, info = "DataFrame column by position 1") + +# test.DataFrame.string.element <- function() { +DF <- data.frame(a=1:3, b=c("a","b","c"), stringsAsFactors=FALSE) +expect_equal( string_element(DF), DF[2,"b"], info = "DataFrame string element") + +# test.DataFrame.CreateOne <- function() { +DF <- data.frame(a=1:3) +expect_equal( createOne(), DF, info = "DataFrame create1") + +# test.DataFrame.CreateTwo <- function() { +DF <- data.frame(a=1:3, b=c("a","b","c")) +expect_equal( createTwo(), DF, info = "DataFrame create2") + +# test.DataFrame.SlotProxy <- function(){ +setClass("track", representation(x="data.frame", y = "function")) +df <- data.frame( x = 1:10, y = 1:10 ) +tr1 <- new( "track", x = df, y = rnorm ) +expect_true( identical( SlotProxy(tr1, "x"), df ), info = "DataFrame( SlotProxy )" ) +expect_error( SlotProxy(tr1, "y"), info = "DataFrame( SlotProxy ) -> exception" ) + +# test.DataFrame.AttributeProxy <- function(){ +df <- data.frame( x = 1:10, y = 1:10 ) +tr1 <- structure( list(), x = df, y = rnorm ) +expect_true( identical( AttributeProxy(tr1, "x"), df) , info = "DataFrame( AttributeProxy )" ) +expect_error( AttributeProxy(tr1, "y"), info = "DataFrame( AttributeProxy ) -> exception" ) + +# test.DataFrame.CreateTwo.stringsAsFactors <- function() { +DF <- data.frame(a=1:3, b=c("a","b","c"), stringsAsFactors = FALSE ) +expect_equal( createTwoStringsAsFactors(), DF, info = "DataFrame create2 stringsAsFactors = false") + +# test.DataFrame.nrow <- function(){ +df <- data.frame( x = 1:10, y = 1:10 ) +expect_equal( DataFrame_nrow( df ), rep(nrow(df), 2) ) + +# test.DataFrame.ncol <- function(){ +df <- data.frame( x = 1:10, y = 1:10 ) +expect_equal( DataFrame_ncol( df ), rep(ncol(df), 2) ) + +# test.DataFrame.PushBackNamed <- function(){ +df <- data.frame( u = c(0, 0), v = c(0, 0) ) +expect_true( is.data.frame( DataFrame_PushBackNamed() ) ) +expect_equal( DataFrame_PushBackNamed(), df ) + +# test.DataFrame.PushBackUnamed <- function(){ +df <- data.frame( u = c(0, 0), c(0, 0) ) +expect_true( is.data.frame( DataFrame_PushBackUnnamed() ) ) +expect_equal( DataFrame_PushBackUnnamed(), df ) + +# test.DataFrame.PushFrontNamed <- function(){ +df <- data.frame( v = c(0, 0), u = c(0, 0) ) +expect_true( is.data.frame( DataFrame_PushFrontNamed() ) ) +expect_equal( DataFrame_PushFrontNamed(), df ) + +# test.DataFrame.PushFrontUnnamed <- function(){ +df <- data.frame( c(0, 0), u = c(0, 0) ) +expect_true( is.data.frame( DataFrame_PushFrontUnnamed() ) ) +expect_equal( DataFrame_PushFrontUnnamed(), df ) + + +# test.DataFrame.PushFrontDataFrame <- function(){ +df <- data.frame( w = c(0, 0), x = c(0, 0), u = c(0, 0), v = c(0, 0) ) +expect_true( is.data.frame( DataFrame_PushFrontDataFrame() ) ) +expect_equal( DataFrame_PushFrontDataFrame(), df ) + +# test.DataFrame.PushBackDataFrame <- function(){ +df <- data.frame( u = c(0, 0), v = c(0, 0), w = c(0, 0), x = c(0, 0) ) +expect_true( is.data.frame( DataFrame_PushBackDataFrame() ) ) +expect_equal( DataFrame_PushBackDataFrame(), df ) + +# test.DataFrame.PushWrongSize <- function(){ +df <- data.frame( u = c(0, 0), v = c(0, 0), w = c(0, 0), x = c(0, 0) ) +expect_warning( DataFrame_PushWrongSize() ) + +# test.DataFrame.PushReplicateLength <- function(){ +df <- data.frame( u = c(1, 0), v = c(0, 0, 0, 0), x = c(2) ) +expect_true( is.data.frame( DataFrame_PushReplicateLength() ) ) +expect_equal( DataFrame_PushReplicateLength(), df ) + +# test.DataFrame.PushZeroLength <- function(){ +expect_warning( DataFrame_PushZeroLength()) + +## issue #1232: push on empty data.frame +df <- DataFrame_PushOnEmpty() +expect_equal(ncol(df), 3L) diff --git a/inst/tinytest/test_date.R b/inst/tinytest/test_date.R new file mode 100644 index 000000000..0c5ffda01 --- /dev/null +++ b/inst/tinytest/test_date.R @@ -0,0 +1,255 @@ + +## Copyright (C) 2010 - 2025 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/dates.cpp") + +# test.Date.ctor.sexp <- function() { +fun <- ctor_sexp +d <- as.Date("2005-12-31"); expect_equal(fun(d), d, info = "Date.ctor.sexp.1") +d <- as.Date("1970-01-01"); expect_equal(fun(d), d, info = "Date.ctor.sexp.2") +d <- as.Date("1969-12-31"); expect_equal(fun(d), d, info = "Date.ctor.sexp.3") +d <- as.Date("1954-07-04"); expect_equal(fun(d), d, info = "Date.ctor.sexp.4") # cf 'Miracle of Berne' ;-) +d <- as.Date("1789-07-14"); expect_equal(fun(d), d, info = "Date.ctor.sexp.5") # cf 'Quatorze Juillet' ;-) + +# test.Date.ctor.notFinite <- function() { +fun <- ctor_sexp +expect_equal(fun(NA), as.Date(NA, origin="1970-01-01"), info = "Date.ctor.na") +expect_equal(fun(NaN), as.Date(NaN, origin="1970-01-01"), info = "Date.ctor.nan") +expect_equal(fun(Inf), as.Date(Inf, origin="1970-01-01"), info = "Date.ctor.inf") + +# test.Date.ctor.diffs <- function() { +fun <- ctor_sexp +now <- Sys.Date() +expect_equal(as.numeric(difftime(fun(now+0.025), fun(now), units="days")), 0.025, info = "Date.ctor.diff.0025") +expect_equal(as.numeric(difftime(fun(now+0.250), fun(now), units="days")), 0.250, info = "Date.ctor.diff.0250") +expect_equal(as.numeric(difftime(fun(now+2.500), fun(now), units="days")), 2.500, info = "Date.ctor.diff.2500") + +# test.Date.ctor.mdy <- function() { +expect_equal(ctor_mdy(), as.Date("2005-12-31"), info = "Date.ctor.mdy") + +# test.Date.ctor.ymd <- function() { +expect_equal(ctor_ymd(), as.Date("2005-12-31"), info = "Date.ctor.ymd") + +# test.Date.ctor.int <- function() { +fun <- ctor_int +d <- as.Date("2005-12-31") +expect_equal(fun(as.numeric(d)), d, info = "Date.ctor.int") +expect_equal(fun(-1), as.Date("1970-01-01")-1, info = "Date.ctor.int") +expect_error(fun("foo"), info = "Date.ctor -> exception" ) + +# test.Date.ctor.string <- function() { +fun <- ctor_string +dtstr <- "1991-02-03" +dtfun <- fun(dtstr) +dtstr <- as.Date(strptime(dtstr, "%Y-%m-%d")) +ddstr <- as.Date(dtstr, "%Y-%m-%d") +expect_equal(dtfun, dtstr, info = "Date.fromString.strptime") +expect_equal(dtfun, ddstr, info = "Date.fromString.asDate") + +# test.Date.operators <- function() { +expect_equal(operators(), + list(diff=-1, bigger=TRUE, smaller=FALSE, equal=FALSE, ge=TRUE, le=FALSE, ne=TRUE), + info = "Date.operators") + + +# test.Date.components <- function() { +expect_equal(components(), + list(day=31, month=12, year=2005, weekday=7, yearday=365), + info = "Date.components") + +# test.vector.Date <- function(){ +expect_equal(vector_Date(), rep(as.Date("2005-12-31"),2), info = "Date.vector.wrap") + +# test.DateVector.wrap <- function(){ +expect_equal(Datevector_wrap(), rep(as.Date("2005-12-31"),2), info = "DateVector.wrap") + +# test.DateVector.operator.SEXP <- function(){ +expect_equal(Datevector_sexp(), rep(as.Date("2005-12-31"),2), info = "DateVector.SEXP") + +# test.Date.getFunctions <- function(){ +fun <- Date_get_functions +expect_equal(fun(as.Date("2010-12-04")), + list(year=2010, month=12, day=4, wday=7, yday=338), info = "Date.get.functions.1") +expect_equal(fun(as.Date("2010-01-01")), + list(year=2010, month=1, day=1, wday=6, yday=1), info = "Date.get.functions.2") +expect_equal(fun(as.Date("2009-12-31")), + list(year=2009, month=12, day=31, wday=5, yday=365), info = "Date.get.functions.3") + +# test.Datetime.get.functions <- function() { +fun <- Datetime_get_functions +expect_equal(fun(as.numeric(as.POSIXct("2001-02-03 01:02:03.123456", tz="UTC"))), + list(year=2001, month=2, day=3, wday=7, hour=1, minute=2, second=3, microsec=123456), + info = "Datetime.get.functions") + +# test.Datetime.operators <- function() { +expect_equal(Datetime_operators(), + list(diff=-60*60, bigger=TRUE, smaller=FALSE, equal=FALSE, ge=TRUE, le=FALSE, ne=TRUE), + info = "Datetime.operators") + +# test.Datetime.wrap <- function() { +expect_equal(as.numeric(Datetime_wrap()), as.numeric(as.POSIXct("2001-02-03 01:02:03.123456", tz="UTC")), + info = "Datetime.wrap") + +# test.Datetime.fromString <- function() { +fun <- Datetime_from_string +dtstr <- "1991-02-03 04:05:06.789" +dtfun <- fun(dtstr) +dtstr <- as.POSIXct(strptime(dtstr, "%Y-%m-%d %H:%M:%OS")) +expect_equal(as.numeric(dtfun), as.numeric(dtstr), info = "Datetime.fromString") + +## TZ difference ... +##test.Datetime.ctor <- function() { +## fun <- .Rcpp.Date$Datetime_ctor_sexp +## expect_equal(fun(1234567), as.POSIXct(1234567, origin="1970-01-01"), info = "Datetime.ctor.1") +## expect_equal(fun(-120.25), as.POSIXct(-120.5, origin="1970-01-01"), info = "Datetime.ctor.2") +## expect_equal(fun( 120.25), as.POSIXct( 120.25, origin="1970-01-01"), info = "Datetime.ctor.3") +##} + +# test.Datetime.ctor.notFinite <- function() { +fun <- Datetime_ctor_sexp +posixtNA <- as.POSIXct(NA, origin="1970-01-01") +expect_equal(fun(NA), posixtNA, info = "Datetime.ctor.na") +expect_equal(fun(NaN), posixtNA, info = "Datetime.ctor.nan") +expect_equal(fun(Inf), posixtNA, info = "Datetime.ctor.inf") + +# test.Datetime.ctor.diffs <- function() { +fun <- Datetime_ctor_sexp +now <- Sys.time() +## first one is Ripley's fault as he decreed that difftime of POSIXct should stop at milliseconds +expect_equal(round(as.numeric(difftime(fun(now+0.025), fun(now), units="sec")), digits=4), 0.025, info = "Datetime.ctor.diff.0025") +expect_equal(as.numeric(difftime(fun(now+0.250), fun(now), units="sec")), 0.250, info = "Datetime.ctor.diff.0250") +expect_equal(as.numeric(difftime(fun(now+2.500), fun(now), units="sec")), 2.500, info = "Datetime.ctor.diff.2500") + +# test.DatetimeVector.ctor <- function() { +fun <- DatetimeVector_ctor +now <- Sys.time() +expect_equal(fun(now + (0:4)*60), now+(0:4)*60, info = "Datetime.ctor.sequence") +if (Rcpp:::capabilities()[["new date(time) vectors"]]) { + vec <- c(now, NA, NaN, now+2.345) + posixtNA <- as.POSIXct(NA, origin="1970-01-01") + expect_equal(fun(vec), c(now, rep(posixtNA, 2), now+2.345), info = "Datetime.ctor.NA.NaN.set") + vec <- c(now, -Inf, Inf, now+2.345) + expect_equal(sum(is.finite(fun(vec))), 2, info = "Datetime.ctor.Inf.finite.set") + expect_equal(sum(is.infinite(fun(vec))), 2, info = "Datetime.ctor.Inf.notfinite.set") + vec <- c(now, NA, NaN, Inf, now+2.345) + posixtNA <- as.POSIXct(NA, origin="1970-01-01") + posixtInf <- as.POSIXct(Inf, origin="1970-01-01") + expect_equal(fun(vec), c(now, rep(posixtNA, 2), posixtInf, now+2.345), + info = "Datetime.ctor.NA.NaN.Inf.set") +} else { + vec <- c(now, NA, NaN, Inf, now+2.345) + posixtNA <- as.POSIXct(NA, origin="1970-01-01") + expect_equal(fun(vec), c(now, rep(posixtNA, 3), now+2.345), info = "Datetime.ctor.NA.NaN.Inf.set") +} + + +# test.DatetimeVector.assignment <- function() { +now <- Sys.time() +v1 <- c(now, now + 1, now + 2) +v2 <- c(now + 3, now + 4, now + 5) +expect_equal(v2, DatetimeVector_assignment(v1, v2)) + +# test.DateVector.assignment <- function() { +now <- Sys.Date() +v1 <- c(now, now + 1, now + 2) +v2 <- c(now + 3, now + 4, now + 5) +expect_equal(v2, DateVector_assignment(v1, v2)) + +## formatting +# test.Date.formating <- function() { +oldTZ <- Sys.getenv("TZ") +if (oldTZ == "America/Chicago") { + ##Sys.setenv(TZ="America/Chicago") + d <- as.Date("2011-12-13") + + expect_equal(Date_format(d, "%Y-%m-%d"), format(d), info="Date.formating.default") + expect_equal(Date_format(d, "%Y/%m/%d"), format(d, "%Y/%m/%d"), info="Date.formating.given.format") + expect_equal(Date_ostream(d), format(d), info="Date.formating.ostream") + ##Sys.setenv(TZ=oldTZ) +} + +#test.Datetime.formating <- function() { +olddigits <- getOption("digits.secs") +options("digits.secs"=6) + +d <- as.POSIXct("2016-12-13 14:15:16.123456") +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:%OS6"), + info="Datetime.formating.given.format") +expect_equal(Datetime_ostream(d), + format(d, "%Y-%m-%d %H:%M:%OS"), + info="Datetime.formating.ostream") +options("digits.secs"=olddigits) + + +# test.mktime_gmtime <- function() { +d <- as.Date("2015-12-31") +expect_equal(d, gmtime_mktime(d), info="Date.mktime_gmtime.2015") + +d <- as.Date("1965-12-31") +expect_equal(d, gmtime_mktime(d), info="Date.mktime_gmtime.1965") + +# test.mktime <- function() { +d <- as.Date("2015-12-31") +expect_equal(test_mktime(d), as.numeric(as.POSIXct(d)), info="Date.test_mktime.2015") + +d <- as.Date("1970-01-01") +expect_equal(test_mktime(d), as.numeric(as.POSIXct(d)), info="Date.test_mktime.1970") + +d <- as.Date("1954-07-04") +expect_equal(test_mktime(d), as.numeric(as.POSIXct(d)), info="Date.test_mktime.1954") + +# test.gmtime <- function() { +oldTZ <- Sys.getenv("TZ") +if (oldTZ == "UTC") { + ##Sys.setenv(TZ="UTC") + expect_equal(test_gmtime(1441065600), as.Date("2015-09-01"), info="Date.test_gmtime.2015") + + expect_equal(test_gmtime(0), as.Date("1970-01-01"), info="Date.test_gmtime.1970") + + expect_equal(test_gmtime(-489024000), as.Date("1954-07-04"), info="Date.test_gmtime.1954") + ##Sys.setenv(TZ=oldTZ) +} + +# test.NA <- function() { +dv <- Sys.Date() + 0:2 +expect_true(has_na_dv(dv) == FALSE, info="DateVector.NAtest.withoutNA") +dv[1] <- NA +expect_true(has_na_dv(dv) == TRUE, info="DateVector.NAtest.withNA") + +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 new file mode 100644 index 000000000..cc368cace --- /dev/null +++ b/inst/tinytest/test_dispatch.R @@ -0,0 +1,75 @@ +#!/usr/bin/env r +# +# Copyright (C) 2009 - 2016 Dirk Eddelbuettel and Romain Francois +# Copyright (C) 2016 - 2019 Dirk Eddelbuettel, Romain Francois and Nathan Russell +# +# 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/dispatch.cpp") + +# test.RawVector <- function() { +x <- as.raw(0:9) +expect_equal(first_el(x), x[1], info = "RCPP_RETURN_VECTOR (raw)") + +# test.ComplexVector <- function() { +x <- as.complex(0:9) +expect_equal(first_el(x), x[1], info = "RCPP_RETURN_VECTOR (complex)") + +# test.IntegerVector <- function() { +x <- as.integer(0:9) +expect_equal(first_el(x), x[1], info = "RCPP_RETURN_VECTOR (integer)") + +# test.NumericVector <- function() { +x <- as.numeric(0:9) +expect_equal(first_el(x), x[1], info = "RCPP_RETURN_VECTOR (numeric)") + +# test.ExpressionVector <- function() { +x <- expression(rnorm, rnorm(10), mean(1:10)) +expect_equal(first_el(x), x[1], info = "RCPP_RETURN_VECTOR (expression)") + +# test.GenericVector <- function() { +x <- list("foo", 10L, 10.2, FALSE) +expect_equal(first_el(x), x[1], info = "RCPP_RETURN_VECTOR (list)") + +# test.CharacterVector <- function() { +x <- as.character(0:9) +expect_equal(first_el(x), x[1], info = "RCPP_RETURN_VECTOR (character)") + +# test.RawMatrix <- function() { +x <- matrix(as.raw(0:9), ncol = 2L) +expect_equal(first_cell(x), x[1, 1, drop = FALSE], info = "RCPP_RETURN_MATRIX (raw)") + +# test.ComplexMatrix <- function() { +x <- matrix(as.complex(0:9), ncol = 2L) +expect_equal(first_cell(x), x[1, 1, drop = FALSE], info = "RCPP_RETURN_MATRIX (complex)") + +# test.IntegerMatrix <- function() { +x <- matrix(as.integer(0:9), ncol = 2L) +expect_equal(first_cell(x), x[1, 1, drop = FALSE], info = "RCPP_RETURN_MATRIX (integer)") + +# test.NumericMatrix <- function() { +x <- matrix(as.numeric(0:9), ncol = 2L) +expect_equal(first_cell(x), x[1, 1, drop = FALSE], info = "RCPP_RETURN_MATRIX (numeric)") + +# test.GenericMatrix <- function() { +x <- matrix(lapply(0:9, function(.) 0:9), ncol = 2L) +expect_equal(first_cell(x), x[1, 1, drop = FALSE], info = "RCPP_RETURN_MATRIX (list)") + +# test.CharacterMatrix <- function() { +x <- matrix(as.character(0:9), ncol = 2L) +expect_equal(first_cell(x), x[1, 1, drop = FALSE], info = "RCPP_RETURN_MATRIX (character)") diff --git a/inst/tinytest/test_embedded_r.R b/inst/tinytest/test_embedded_r.R new file mode 100644 index 000000000..967a22570 --- /dev/null +++ b/inst/tinytest/test_embedded_r.R @@ -0,0 +1,39 @@ + +## Copyright (C) 2012 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +library(Rcpp) + +# test.embeddedR <- function() { +path <- "cpp" #file.path(system.file("unitTests", package = "Rcpp"), "cpp") +expectedVars <- c("foo", "x") + +## embeddedR.cpp exposes the function foo, R snippet calls foo +newEnv <- new.env(parent = baseenv()) + +sink(tempfile()) # NB: silencing output + +sourceCpp("cpp/embeddedR.cpp", env = newEnv) +expect_equal(ls(newEnv), expectedVars, msg = "sourcing code in custom env") + +## R snippet in embeddedR2.cpp also contains a call to foo from previous cpp +newEnv2 <- new.env(parent = baseenv()) +expect_error(sourceCpp("cpp/embeddedR2.cpp", env = newEnv2), 'could not find function "foo"') + +sink(NULL) # NB: restoring diff --git a/inst/tinytest/test_environments.R b/inst/tinytest/test_environments.R new file mode 100644 index 000000000..41928d437 --- /dev/null +++ b/inst/tinytest/test_environments.R @@ -0,0 +1,271 @@ + +## Copyright (C) 2009 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/Environment.cpp") + +# test.environment.ls <- function(){ +e <- new.env( ) +e$a <- 1:10 +e$b <- "foo" +e$.c <- "hidden" +expect_equal( sort(runit_ls(e)), sort(c("a","b", ".c")), info = "Environment::ls(true)" ) +expect_equal( runit_ls(asNamespace("Rcpp")), ls(envir=asNamespace("Rcpp"), all = TRUE), + info = "Environment(namespace)::ls()" ) + +expect_equal( runit_ls2(e), c("a","b"), info = "Environment::ls(false)" ) +expect_equal( runit_ls2(asNamespace("Rcpp")), ls(envir=asNamespace("Rcpp"), all = FALSE), + info = "Environment(namespace)::ls()" ) + +# test.environment.get <- function(){ +e <- new.env( ) +e$a <- 1:10 +e$b <- "foo" + +## Access with string +expect_equal( runit_get( e, "a" ), e$a, info = "Environment::get(string)" ) +expect_equal( runit_get( e, "foobar" ), NULL, info = "Environment::get(string)" ) +expect_equal( runit_get( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, + info = "Environment(namespace)::get(string) " ) + +## Access with Symbol constructed on call from string +expect_equal( runit_get_symbol( e, "a" ), e$a, info = "Environment::get(Symbol)" ) +expect_equal( runit_get_symbol( e, "foobar" ), NULL, info = "Environment::get(Symbol)" ) +expect_equal( runit_get_symbol( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, + info = "Environment(namespace)::get(Symbol) " ) + +# test.environment.find <- function(){ +e <- new.env( ) +e$a <- 1:10 +e$b <- "foo" +bar <- "me" + +## Access with string +expect_equal( runit_find( e, "a" ), e$a, info = "Environment::find(string)" ) +expect_error( runit_find( e, "foobar" ), info = "Environment::find(string) not found" ) +expect_equal( runit_find( e, "bar"), bar, info = "Environment::find(string) inheritance" ) +expect_equal( runit_find( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, + info = "Environment(namespace)::find(string)" ) + +## Access with Symbol constructed on call from string +expect_equal( runit_find_symbol( e, "a" ), e$a, info = "Environment::find(Symbol)" ) +expect_error( runit_find_symbol( e, "foobar" ), info = "Environment::find(Symbol) not found" ) +expect_equal( runit_find_symbol( e, "bar"), bar, info = "Environment::find(Symbol) inheritance" ) +expect_equal( runit_find_symbol( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, + info = "Environment(namespace)::find(Symbol)" ) + +# test.environment.exists <- function(){ +e <- new.env( ) +e$a <- 1:10 +e$b <- "foo" + +expect_true( runit_exists( e, "a" ), info = "Environment::get()" ) +expect_true( !runit_exists( e, "foobar" ), info = "Environment::get()" ) +expect_true( runit_exists( asNamespace("Rcpp"), "CxxFlags"), + info = "Environment(namespace)::get() " ) + +# test.environment.assign <- function(){ +e <- new.env( ) +expect_true( runit_assign(e, "a", 1:10 ), info = "Environment::assign" ) +expect_true( runit_assign(e, "b", Rcpp:::CxxFlags ), info = "Environment::assign" ) +expect_equal( ls(e), c("a", "b"), info = "Environment::assign, checking names" ) +expect_equal( e$a, 1:10, info = "Environment::assign, checking value 1" ) +expect_equal( e$b, Rcpp:::CxxFlags, info = "Environment::assign, checking value 2" ) + +lockBinding( "a", e ) +can.demangle <- Rcpp:::capabilities()[["demangling"]] +if( can.demangle ){ + expect_true( + tryCatch( { runit_assign(e, "a", letters ) ; FALSE}, "Rcpp::binding_is_locked" = function(e) TRUE ), + info = "cannot assign to locked binding (catch exception)" ) +} else { + expect_true( + tryCatch( { runit_assign(e, "a", letters ) ; FALSE}, "error" = function(e) TRUE ), + info = "cannot assign to locked binding (catch exception)" ) +} + +# test.environment.isLocked <- function(){ +e <- new.env() +runit_islocked(e) +expect_equal( e[["x1"]], 1L , info = "Environment::assign( int ) " ) +expect_equal( e[["x2"]], 10.0, info = "Environment::assign( double ) " ) +expect_equal( e[["x3"]], "foobar", info = "Environment::assign( char* ) " ) +expect_equal( e[["x4"]], "foobar", info = "Environment::assign( std::string ) " ) +expect_equal( e[["x5"]], c("foo", "bar" ), info = "Environment::assign( vector ) " ) + +# test.environment.bindingIsActive <- function(){ +e <- new.env() +e$a <- 1:10 +makeActiveBinding( "b", function(x) 10, e ) + +expect_true( !runit_bindingIsActive(e, "a" ), info = "Environment::bindingIsActive( non active ) -> false" ) +expect_true( runit_bindingIsActive(e, "b" ), info = "Environment::bindingIsActive( active ) -> true" ) + +can.demangle <- Rcpp:::capabilities()[["demangling"]] +if( can.demangle ){ + expect_true( + tryCatch( { runit_bindingIsActive(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), + info = "Environment::bindingIsActive(no binding) -> exception)" ) +} else { + expect_true( + tryCatch( { runit_bindingIsActive(e, "xx" ) ; FALSE}, error = function(e) TRUE ), + info = "Environment::bindingIsActive(no binding) -> exception)" ) +} + +# test.environment.bindingIsLocked <- function(){ +e <- new.env() +e$a <- 1:10 +e$b <- letters +lockBinding( "b", e ) + +expect_true( !runit_bindingIsLocked(e, "a" ), info = "Environment::bindingIsActive( non active ) -> false" ) +expect_true( runit_bindingIsLocked(e, "b" ), info = "Environment::bindingIsActive( active ) -> true" ) + +can.demangle <- Rcpp:::capabilities()[["demangling"]] +if( can.demangle ){ + expect_true( + tryCatch( { runit_bindingIsLocked(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), + info = "Environment::bindingIsLocked(no binding) -> exception)" ) +} else { + expect_true( + tryCatch( { runit_bindingIsLocked(e, "xx" ) ; FALSE}, error = function(e) TRUE ), + info = "Environment::bindingIsLocked(no binding) -> exception)" ) +} + +# test.environment.NotAnEnvironment <- function(){ +expect_error( runit_notanenv( runit_notanenv ), info = "not an environment" ) +expect_error( runit_notanenv( letters ), info = "not an environment" ) +expect_error( runit_notanenv( NULL ), info = "not an environment" ) + +# test.environment.lockBinding <- function(){ +e <- new.env() +e$a <- 1:10 +e$b <- letters +runit_lockbinding(e, "b") +expect_true( bindingIsLocked("b", e ), info = "Environment::lockBinding()" ) + +can.demangle <- Rcpp:::capabilities()[["demangling"]] +if( can.demangle ){ + expect_true( + tryCatch( { runit_lockbinding(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), + info = "Environment::lockBinding(no binding) -> exception)" ) +} else { + expect_true( + tryCatch( { runit_lockbinding(e, "xx" ) ; FALSE}, error = function(e) TRUE ), + info = "Environment::lockBinding(no binding) -> exception)" ) +} + +# test.environment.unlockBinding <- function(){ +e <- new.env() +e$a <- 1:10 +e$b <- letters +lockBinding( "b", e ) +runit_unlockbinding(e, "b") +expect_true( !bindingIsLocked("b", e ), info = "Environment::lockBinding()" ) + +can.demangle <- Rcpp:::capabilities()[["demangling"]] +if( can.demangle ){ + expect_true( + tryCatch( { runit_unlockbinding(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), + info = "Environment::unlockBinding(no binding) -> exception)" ) +} else { + expect_true( + tryCatch( { runit_unlockbinding(e, "xx" ) ; FALSE}, error = function(e) TRUE ), + info = "Environment::unlockBinding(no binding) -> exception)" ) +} + +# test.environment.global.env <- function(){ +expect_identical( runit_globenv(), globalenv(), info = "Environment::global_env" ) + +# test.environment.empty.env <- function(){ +expect_identical( runit_emptyenv(), emptyenv(), info = "Environment::empty_env" ) + +# test.environment.base.env <- function(){ +expect_identical( runit_baseenv(), baseenv(), info = "Environment::base_env" ) + +# test.environment.namespace.env <- function(){ +expect_identical( runit_namespace("Rcpp"), asNamespace("Rcpp"), info = "Environment::base_namespace" ) + +can.demangle <- Rcpp:::capabilities()[["demangling"]] +if( can.demangle ){ + expect_true( + tryCatch( { runit_namespace("----" ) ; FALSE}, "Rcpp::no_such_namespace" = function(e) TRUE ), + info = "Environment::namespace_env(no namespace) -> exception)" ) +} else { + expect_true( + tryCatch( { runit_namespace("----" ) ; FALSE}, error = function(e) TRUE ), + info = "Environment::namespace_env(no namespace) -> exception)" ) +} + +# test.environment.constructor.SEXP <- function(){ +expect_identical( runit_env_SEXP( globalenv() ), globalenv(), info = "Environment( environment ) - 1" ) +expect_identical( runit_env_SEXP( baseenv() ), baseenv(), info = "Environment( environment ) - 2" ) +expect_identical( runit_env_SEXP( asNamespace("Rcpp") ), asNamespace("Rcpp"), info = "Environment( environment ) - 3" ) + +expect_identical( runit_env_SEXP( ".GlobalEnv" ), globalenv(), info = "Environment( character ) - 1" ) +expect_identical( runit_env_SEXP( "package:base" ), baseenv(), info = "Environment( character ) - 2" ) +expect_identical( runit_env_SEXP( "package:Rcpp" ), as.environment("package:Rcpp") , info = 'Environment( "package:Rcpp") ' ) + +expect_identical( runit_env_SEXP(1L), globalenv(), info = "Environment( SEXP{integer} )" ) + +# test.environment.constructor.stdstring <- function(){ +expect_identical( runit_env_string( ".GlobalEnv" ), globalenv(), info = "Environment( std::string ) - 1" ) +expect_identical( runit_env_string( "package:base" ), baseenv(), info = "Environment( std::string ) - 2" ) +expect_identical( runit_env_string( "package:Rcpp" ), as.environment("package:Rcpp") , + info = 'Environment( std::string ) - 3' ) + + +# test.environment.constructor.int <- function(){ +for( i in 1:length(search())){ + expect_identical( runit_env_int(i), as.environment(i), info = sprintf("Environment(int) - %d", i) ) +} + +# test.environment.remove <- function(){ +e <- new.env( ) +e$a <- 1 +e$b <- 2 +expect_true( runit_remove( e, "a" ), info = "Environment::remove" ) +expect_equal( ls(envir=e), "b", info = "check that the element was removed" ) +expect_error( runit_remove(e, "xx"), info = "Environment::remove no such binding" ) +lockBinding( "b", e ) +expect_error( runit_remove(e, "b"), info = "Environment::remove binding is locked" ) +expect_equal( ls(envir=e), "b", info = "check that the element was not removed" ) + +# test.environment.parent <- function(){ +e <- new.env( parent = emptyenv() ) +f <- new.env( parent = e ) +expect_equal( runit_parent(f), e, info = "Environment::parent" ) +expect_equal( runit_parent(e), emptyenv() , info = "Environment::parent" ) + +# test.environment.square <- function(){ +env <- new.env( ) +env[["x"]] <- 10L +expect_equal( runit_square(env), list( 10L, 2L, "foo") ) + +# test.environment.Rcpp <- function(){ +expect_equal( runit_Rcpp(), asNamespace("Rcpp") , info = "cached Rcpp namespace" ) + +##test.environment.child <- function(){ +## expect_equal( parent.env(runit_child()), globalenv(), info = "child environment" ) +##} + +# test.environment.new_env <- function() { +env <- new.env() +expect_identical(parent.env(runit_new_env_default()), emptyenv(), info = "new environment with default parent") +expect_identical(parent.env(runit_new_env_parent(env)), env, info = "new environment with specified parent") diff --git a/inst/tinytest/test_exceptions.R b/inst/tinytest/test_exceptions.R new file mode 100644 index 000000000..c7d853728 --- /dev/null +++ b/inst/tinytest/test_exceptions.R @@ -0,0 +1,123 @@ + +## Copyright (C) 2010 - 2022 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +## used below +.onWindows <- .Platform$OS.type == "windows" +.onSolaris <- Sys.info()[["sysname"]] == "SunOS" + +Rcpp::sourceCpp("cpp/exceptions.cpp") + +#test.stdException <- function() { +## Code works normally without an exception +expect_identical(takeLog(1L), log(1L)) + +## C++ exceptions are converted to R conditions +condition <- tryCatch(takeLog(-1L), error = identity) + +expect_identical(condition$message, "Inadmissible value") +expect_identical(class(condition), c("std::range_error", "C++Error", "error", "condition")) + +## C++ stack only available for Rcpp::exceptions +expect_true(is.null(condition$cppstack)) + +#expect_identical(condition$call, quote(takeLog(-1L))) + + +#test.rcppException <- function() { + +## Code works normally without an exception +expect_identical(takeLog(1L), log(1L)) + +## C++ exceptions are converted to R conditions +condition <- tryCatch(takeLogRcpp(-1L), error = identity) + +expect_identical(condition$message, "Inadmissible value") +expect_identical(class(condition), c("Rcpp::exception", "C++Error", "error", "condition")) + +if (.onWindows) exit_file("Skipping remainder of file on Windows") +if (.onSolaris) exit_file("Skipping remainder of file on Solaris") + +expect_true(!is.null(condition$cppstack)) + +expect_identical(class(condition$cppstack), "Rcpp_stack_trace") + +#expect_equal(condition$call, quote(takeLogRcpp(-1L))) + + +#test.rcppStop <- function() { +## Code works normally without an exception +expect_identical(takeLog(1L), log(1L)) + +## C++ exceptions are converted to R conditions +condition <- tryCatch(takeLogStop(-1L), error = identity) + +expect_identical(condition$message, "Inadmissible value") +expect_identical(class(condition), c("Rcpp::exception", "C++Error", "error", "condition")) + +expect_true(!is.null(condition$cppstack)) + +expect_identical(class(condition$cppstack), "Rcpp_stack_trace") + +#expect_equal(condition$call, quote(takeLogStop(-1L))) + + +#test.rcppExceptionLocation <- function() { + +## Code works normally without an exception +expect_identical(takeLog(1L), log(1L)) + +## C++ exceptions are converted to R conditions +condition <- tryCatch(takeLogRcppLocation(-1L), error = identity) + +expect_identical(condition$message, "Inadmissible value") +expect_identical(class(condition), c("Rcpp::exception", "C++Error", "error", "condition")) + +expect_true(!is.null(condition$cppstack)) +expect_identical(class(condition$cppstack), "Rcpp_stack_trace") + +#expect_identical(condition$cppstack$file, "exceptions.cpp") +#expect_identical(condition$cppstack$line, 44L) + +#expect_equal(condition$call, quote(takeLogRcppLocation(-1L))) + + +#test.rcppExceptionLocation <- function() { + +## Nested exceptions work the same way +normal <- tryCatch(takeLogRcppLocation(-1L), error = identity) +f1 <- function(x) takeLogNested(x) + +nested <- tryCatch(f1(-1), error = identity) + +## Message the same +expect_identical(normal$message, nested$message) + +#expect_equal(nested$call, quote(takeLogNested(x))) + + +#test.rcppExceptionNoCall <- function() { + +## Can throw exceptions that don't include a call stack +e <- tryCatch(noCall(), error = identity) + +expect_identical(e$message, "Testing") +expect_identical(e$call, NULL) +expect_identical(e$cppstack, NULL) +expect_identical(class(e), c("Rcpp::exception", "C++Error", "error", "condition")) diff --git a/inst/tinytest/test_exceptions_nocall.R b/inst/tinytest/test_exceptions_nocall.R new file mode 100644 index 000000000..d96cc5ef0 --- /dev/null +++ b/inst/tinytest/test_exceptions_nocall.R @@ -0,0 +1,33 @@ + +## Copyright (C) 2018 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/Exceptions_nocall.cpp") + +# test.Rcpp_exception <- function() { +tryCatch(Rcpp_exception(), error = function(e){ + expect_true(is.null(e$call)) + expect_true(is.null(e$cppstack)) +}) + +# test.eval_error <- function() { +tryCatch(eval_error_no_call(), error = function(e){ + expect_true(is.null(e$call)) + expect_true(is.null(e$cppstack)) +}) diff --git a/inst/tinytest/test_expose_class.R b/inst/tinytest/test_expose_class.R new file mode 100644 index 000000000..a0662f998 --- /dev/null +++ b/inst/tinytest/test_expose_class.R @@ -0,0 +1,111 @@ + +## Copyright (C) 2013 - 2019 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 . + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") + +library(Rcpp) + +tempdir <- tempdir() +## foo has already been loaded in test.Rcpp.package.skeleton.R, +## so named differently here to avoid namespace conflicts +pkg_name <- "fooModule" +path <- tempdir +pkg_path <- file.path(path, pkg_name) +R_path <- file.path(pkg_path, "R") +src_path <- file.path(pkg_path, "src") +foo_header <- " +#ifndef foo_h +#define foo_h 1 +// class to set/get double +class foo { + public: + double x; + double get_x() {return x;} + void set_x(double _x) {x = _x; return;} + foo(double _x) {set_x(_x);} +}; +#endif +" + +## create package +if (dir.exists(pkg_path)) unlink(pkg_path) +Rcpp.package.skeleton(pkg_name, path=path, environment = environment(), + example_code = FALSE, module = TRUE) +## R 4.0.0 (currently in development) is stricter about the NAMESPACE and wants +## - an actual function behind the export declaration we end up with here +## - an export declaration for the class exposed and check below +## so we provide both to comply (and also no longer delete from src/ and R/) +cat("Rcpp.fake.fun <- function() {}", file=file.path(path, pkg_name, "R", "fakefun.R")) +cat("export(\"fooR\")", append=TRUE, file=file.path(path, pkg_name, "NAMESPACE")) + +#on.exit(unlink(pkg_path, recursive=TRUE)) +cat(foo_header, file = file.path(src_path, "foo.h")) + +## check that result of exposeClass compiles and runs properly +exposeClass(class = "fooR", + constructors = list("double"), + fields = "x", + methods = c("get_x", "set_x"), + header = '#include "foo.h"', + CppClass = "foo", + rename = c(y = "x", get_y = "get_x", set_y = "set_x"), + file = file.path(src_path, "fooModule.cpp"), + Rfile = file.path(R_path, "fooClass.R")) +compileAttributes(pkg_path) +invisible(sapply( list.files( file.path(pkg_path, "man"), full.names=TRUE), unlink )) + +## check build +owd <- getwd() +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, "_0.0.1.tar.gz") +expect_true( file.exists(gz_name), info = "can successfully R CMD build the pkg") + +## check install + require +templibdir <- file.path(path, "templib") +dir.create(templibdir) +install.packages(gz_name, templibdir, repos=NULL, type="source") +on.exit( unlink( file.path(path, gz_name) ), add=TRUE) +status <- require(pkg_name, file.path(path, "templib"), character.only=TRUE) +#on.exit( unlink( file.path(path, "templib"), recursive=TRUE), add=TRUE ) +expect_true(status, info = "can successfully require the pkg") + +## check object creation +bar <- fooR(0) +env <- environment() +expect_true(exists("bar", envir = env, inherits = FALSE), + info = "module object successfully instantiated" ) +gs <- replicate(n = 10, { + y <- rnorm(1) + bar$set_y(y) + bar$get_y() - y +}) +expect_true(all(gs == 0), info = "renamed methods function as expected" ) +gs <- replicate(n = 10, { + y <- rnorm(1) + bar$set_y(y) + bar$y - y +}) +expect_true( all(gs == 0), info = "renamed direct field functions as expected" ) + +on.exit(unlink(pkg_path, recursive=TRUE), add=TRUE) +on.exit(unlink(templibdir, recursive=TRUE), add=TRUE ) diff --git a/inst/tinytest/test_function.R b/inst/tinytest/test_function.R new file mode 100644 index 000000000..3ee63be0b --- /dev/null +++ b/inst/tinytest/test_function.R @@ -0,0 +1,83 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/Function.cpp") + +# test.Function <- function(){ +expect_equal( function_( rnorm ), rnorm, info = "Function( CLOSXP )" ) +expect_equal( function_( is.function ), is.function, info = "Pairlist( BUILTINSXP )" ) + +expect_error( function_(1:10), info = "Function( INTSXP) " ) +expect_error( function_(TRUE), info = "Function( LGLSXP )" ) +expect_error( function_(1.3), info = "Function( REALSXP) " ) +expect_error( function_(as.raw(1) ), info = "Function( RAWSXP)" ) +expect_error( function_(new.env()), info = "Function not compatible with environment" ) + +# test.Function.variadic <- function(){ +expect_equal( function_variadic( sort, sample(1:20) ), 20:1, info = "calling function" ) +expect_error( function_variadic(sort, sort), info = "Function, R error -> exception" ) + +# test.Function.env <- function(){ +expect_equal( function_env(rnorm), asNamespace("stats" ), info = "Function::environment" ) +expect_error( function_env(is.function), + info = "Function::environment( builtin) : exception" ) +expect_error( function_env(`~`), + info = "Function::environment( special) : exception" ) + +# test.Function.unary.call <- function(){ +expect_equal(function_unarycall( lapply( 1:10, function(n) seq(from=n, to = 0 ) ) ), + 2:11 , info = "unary_call(Function)" ) + +# test.Function.binary.call <- function(){ +data <- lapply( 1:10, function(n) seq(from=n, to = 0 ) ) +res <- function_binarycall( data , rep(5L,10) ) +expected <- lapply( data, pmin, 5 ) +expect_equal( res, expected, info = "binary_call(Function)" ) + +# test.Function.namespace.env <- function() { +exportedfunc <- function_namespace_env() +expect_equal( stats:::.asSparse, exportedfunc, info = "namespace_env(Function)" ) + +# test.Function.cons.env <- function() { +parent_env <- new.env() +parent_env$fun_parent <- rbinom +child_env <- new.env(parent = parent_env) +child_env$fun_child <- rnorm + +expect_equal(rnorm, function_cons_env("fun_child", child_env), info = "env-lookup constructor") +expect_equal(rbinom, function_cons_env("fun_parent", child_env), + info = "env-lookup constructor: search function in parent environments") +expect_error(function_cons_env("fun_child", parent_env), + info = "env-lookup constructor: fail when function not found") + +# test.Function.cons.ns <- function() { +expect_equal(Rcpp::sourceCpp, function_cons_ns("sourceCpp", "Rcpp"), + info = "namespace-lookup constructor") +expect_error(function_cons_ns("sourceCpp", "Rcppp"), + info = "namespace-lookup constructor: fail when ns does not exist") +expect_error(function_cons_ns("sourceCppp", "Rcpp"), + info = "namespace-lookup constructor: fail when function not found") + +# test.Function.eval <- function() { +expect_error(exec(stop)) +## should not throw exception +exec(function() try(silent = TRUE, exec(stop))) + +## also check function is found in parent env diff --git a/inst/tinytest/test_global_rostream.R b/inst/tinytest/test_global_rostream.R new file mode 100644 index 000000000..156be58fb --- /dev/null +++ b/inst/tinytest/test_global_rostream.R @@ -0,0 +1,108 @@ + +## Copyright (C) 2021 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 . + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") + +library(Rcpp) + +mkv <- "PKG_CPPFLAGS = -DRCPP_USE_GLOBAL_ROSTREAM" +cfg <- " +#ifndef RCPP_USE_GLOBAL_ROSTREAM +#define RCPP_USE_GLOBAL_ROSTREAM +#endif +#include +using namespace Rcpp;" +ptr <- " +// [[Rcpp::export]] +CharacterVector ptr%s() { + CharacterVector out(2); + std::ostringstream Rcout_address, Rcerr_address; + Rcout_address << (void const *)(&Rcout); + Rcerr_address << (void const *)(&Rcerr); + out[0] = Rcout_address.str(); + out[1] = Rcerr_address.str(); + return out; +}" +alig <- " +// [[Rcpp::export]] +void toLeft() { + Rcout << std::left; + Rcerr << std::left; +} +// [[Rcpp::export]] +void toRight() { + Rcout << std::right; + Rcerr << std::right; +}" +print <- ' +// [[Rcpp::export]] +void something() { + Rcout << std::setw(20) << "somethingRcout" << std::endl; + Rcerr << std::setw(20) << "somethingRcerr" << std::endl; +}' + +# create package and write functions into separate translation units +pkg_name <- "fooRostream" +path <- tempdir() +pkg_path <- file.path(path, pkg_name) +src_path <- file.path(pkg_path, "src") + +if (dir.exists(pkg_path)) unlink(pkg_path) +Rcpp.package.skeleton( + pkg_name, path=path, environment=environment(), example_code=FALSE) +writeLines(c(cfg, sprintf(ptr, "A")), file.path(src_path, "ptrA.cpp")) +writeLines(c(cfg, sprintf(ptr, "B")), file.path(src_path, "ptrB.cpp")) +writeLines(c(cfg, alig), file.path(src_path, "alig.cpp")) +writeLines(c(cfg, print), file.path(src_path, "print.cpp")) +writeLines(mkv, file.path(src_path, "Makevars")) +compileAttributes(pkg_path) + +# tests +testRostream <- function() { + captureFun <- function(...) { + err <- capture.output( + out <- capture.output(..., type="output"), type="message") + c(out, err) + } + res <- all(ptrA() == ptrB()) + res <- c(res, all(grepl("^ ", captureFun(something())))) + toLeft() # change alignment globally + res <- c(res, all(grepl("^s", captureFun(something())))) + toRight() # restore + res +} + +# test package +lib_path <- file.path(path, "templib") +dir.create(lib_path) +install.packages(pkg_path, lib_path, repos=NULL, type="source") +expect_true(require("fooRostream", lib.loc=lib_path, character.only=TRUE)) +expect_true(all(testRostream())) + +# test sourceCpp +sourceCpp(file.path(src_path, "ptrA.cpp")) +sourceCpp(file.path(src_path, "ptrB.cpp")) +sourceCpp(file.path(src_path, "alig.cpp")) +sourceCpp(file.path(src_path, "print.cpp")) +expect_true(all(testRostream())) + +# cleanup +on.exit(unlink(pkg_path, recursive=TRUE), add=TRUE) +on.exit(unlink(lib_path, recursive=TRUE), add=TRUE) diff --git a/inst/tinytest/test_interface.R b/inst/tinytest/test_interface.R new file mode 100644 index 000000000..707571f27 --- /dev/null +++ b/inst/tinytest/test_interface.R @@ -0,0 +1,100 @@ + +## Copyright (C) 2018 - 2022 RStudio +## +## 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 . + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") + +library(Rcpp) + +build_package <- function(name, lib_path, tempdir = getwd(), + config = character()) { + file.copy(system.file("tinytest", name, package = "Rcpp"), + getwd(), + recursive = TRUE) + + src_path <- file.path(tempdir, name) + Rcpp::compileAttributes(src_path) + writeLines(config, file.path(src_path, "src", "config.h")) + + install.packages( + src_path, + lib_path, + repos = NULL, + type = "source", + INSTALL_opts = "--install-tests" + ) +} + +# test.interface.unwind <- function() { +exporter_name <- "testRcppInterfaceExporter" +user_name <- "testRcppInterfaceUser" + +tempdir <- tempfile() +dir.create(tempdir) +old_wd <- setwd(tempdir) + +lib_path <- file.path(tempdir, "templib") +dir.create(lib_path) + +old_lib_paths <- .libPaths() +on.exit(.libPaths(old_lib_paths), add = TRUE) +.libPaths(c(lib_path, old_lib_paths)) + +## Without this testInstalledPackage() won't find installed +## packages even though we've passed `lib.loc` +old_libs_envvar <- Sys.getenv("R_LIBS") +on.exit(Sys.setenv(R_LIBS = old_libs_envvar), add = TRUE) + +sys_sep <- if (.Platform$OS.type == "windows") ";" else ":" +Sys.setenv(R_LIBS = paste(c(lib_path, old_lib_paths), collapse = sys_sep)) + +build_package(exporter_name, lib_path) +build_package(user_name, lib_path) + +result <- tools::testInstalledPackage(user_name, lib.loc = lib_path, types = "test") + +## Be verbose if tests were not successful +if (result) { + log <- file.path(paste0(user_name, "-tests"), "tests.Rout.fail") + cat(">> PROTECTED tests.Rout.fail", readLines(log), sep = "\n", file = stderr()) +} + +expect_equal(result, 0L) + + +## Now test client package without protected evaluation +unlink(user_name, recursive = TRUE) +unlink(paste0(user_name, "-tests"), recursive = TRUE) + +## no longer supported in code +## build_package(user_name, lib_path, config = "#define RCPP_NO_UNWIND_PROTECT") + +## result <- tools::testInstalledPackage(user_name, lib.loc = lib_path, types = "test") + +## 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) + unlink(tempdir, recursive = TRUE) +}) diff --git a/inst/tinytest/test_internal_function.R b/inst/tinytest/test_internal_function.R new file mode 100644 index 000000000..939a4dca5 --- /dev/null +++ b/inst/tinytest/test_internal_function.R @@ -0,0 +1,29 @@ + +## Copyright (C) 2014 - 2019 Christian Authmann +## +## 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/InternalFunction.cpp") + +# test.internal_function_add <- function(){ +fun <- getAdd() +expect_equal( fun(10,32), 42 ) + +# test.internal_function_concatenate <- function(){ +fun <- getConcatenate() +expect_equal( fun("Hello"," World"), "Hello World" ) diff --git a/inst/tinytest/test_internal_function_cpp11.R b/inst/tinytest/test_internal_function_cpp11.R new file mode 100644 index 000000000..8ee5c01bc --- /dev/null +++ b/inst/tinytest/test_internal_function_cpp11.R @@ -0,0 +1,31 @@ + +## Copyright (C) 2014 - 2019 Christian Authmann +## +## 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.") + +if (!Rcpp:::capabilities()[["Full C++11 support"]]) exit_file("No C++11 support") + +Rcpp::sourceCpp("cpp/InternalFunctionCPP11.cpp") + +# test.internal_function_add <- function(){ +fun <- getAdd4() +expect_equal( fun(38), 42 ) + +# test.internal_function_concatenate <- function(){ +fun <- getConcatenate() +expect_equal( fun("Hello"," World"), "Hello World" ) diff --git a/inst/tinytest/test_language.R b/inst/tinytest/test_language.R new file mode 100644 index 000000000..b7eef0b88 --- /dev/null +++ b/inst/tinytest/test_language.R @@ -0,0 +1,143 @@ + +## 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/language.cpp") + +# test.Language <- function(){ +expect_equal( runit_language( call("rnorm") ), call("rnorm" ), info = "Language( LANGSXP )" ) +expect_error( runit_language(test.Language), info = "Language not compatible with function" ) +expect_error( runit_language(new.env()), info = "Language not compatible with environment" ) +expect_error( runit_language(1:10), info = "Language not compatible with integer" ) +expect_error( runit_language(TRUE), info = "Language not compatible with logical" ) +expect_error( runit_language(1.3), info = "Language not compatible with numeric" ) +expect_error( runit_language(as.raw(1) ), info = "Language not compatible with raw" ) + +# test.Language.variadic <- function(){ +expect_equal( runit_lang_variadic_1(), call("rnorm", 10L, 0.0, 2.0 ), + info = "variadic templates" ) + +expect_equal( runit_lang_variadic_2(), call("rnorm", 10L, mean = 0.0, 2.0 ), + info = "variadic templates (with names)" ) + +## same as above but without variadic templates +# test.Language.push.back <- function(){ +expect_equal( runit_lang_push_back(), + call("rnorm", 10L, mean = 0.0, 2.0 ), + info = "Language::push_back" ) + +# test.Language.square <- function(){ +expect_equal( runit_lang_square_rv(), 10.0, info = "Language::operator[] used as rvalue" ) +expect_equal( runit_lang_square_lv(), call("rnorm", "foobar", 20.0, 20.0) , info = "Pairlist::operator[] used as lvalue" ) + +# test.Language.function <- function(){ +expect_equal( runit_lang_fun(sort, sample(1:10)), 1:10, info = "Language( Function ) " ) + +# test.Language.inputoperator <- function(){ +expect_equal( runit_lang_inputop(), call("rnorm", 10L, sd = 10L ) , info = "Language<<" ) + +# test.Language.unary.call <- function(){ +expect_equal( + runit_lang_unarycall( 1:10 ), + lapply( 1:10, function(n) seq(from=n, to = 0 ) ), + info = "c++ lapply using calls" ) + +# test.Language.unary.call.index <- function(){ +expect_equal( + runit_lang_unarycallindex( 1:10 ), + lapply( 1:10, function(n) seq(from=10, to = n ) ), + info = "c++ lapply using calls" ) + +# test.Language.binary.call <- function(){ +expect_equal( + runit_lang_binarycall( 1:10, 11:20 ), + lapply( 1:10, function(n) seq(n, n+10) ), + info = "c++ lapply using calls" ) + +# test.Language.fixed.call <- function(){ +set.seed(123) +res <- runit_lang_fixedcall() +set.seed(123) +exp <- lapply( 1:10, function(n) rnorm(10) ) +expect_equal( res, exp, info = "std::generate" ) + +# test.Language.in.env <- function(){ +e <- new.env() +e[["y"]] <- 1:10 +expect_equal( runit_lang_inenv(e), sum(1:10), info = "Language::eval( SEXP )" ) + +# test.Pairlist <- function(){ +expect_equal( runit_pairlist( pairlist("rnorm") ), pairlist("rnorm" ), info = "Pairlist( LISTSXP )" ) +expect_equal( runit_pairlist( call("rnorm") ), pairlist(as.name("rnorm")), info = "Pairlist( LANGSXP )" ) +expect_equal( runit_pairlist(1:10), as.pairlist(1:10) , info = "Pairlist( INTSXP) " ) +expect_equal( runit_pairlist(TRUE), as.pairlist( TRUE) , info = "Pairlist( LGLSXP )" ) +expect_equal( runit_pairlist(1.3), as.pairlist(1.3), info = "Pairlist( REALSXP) " ) +expect_equal( runit_pairlist(as.raw(1) ), as.pairlist(as.raw(1)), info = "Pairlist( RAWSXP)" ) + +expect_error( runit_pairlist(runit_pairlist), info = "Pairlist not compatible with function" ) +expect_error( runit_pairlist(new.env()), info = "Pairlist not compatible with environment" ) + +# test.Pairlist.variadic <- function(){ +expect_equal( runit_pl_variadic_1(), pairlist("rnorm", 10L, 0.0, 2.0 ), + info = "variadic templates" ) +expect_equal( runit_pl_variadic_2(), pairlist("rnorm", 10L, mean = 0.0, 2.0 ), + info = "variadic templates (with names)" ) + +# test.Pairlist.push.front <- function(){ +expect_equal( runit_pl_push_front(), + pairlist( foobar = 10, "foo", 10.0, 1L), + info = "Pairlist::push_front" ) + +# test.Pairlist.push.back <- function(){ +expect_equal( runit_pl_push_back(), + pairlist( 1L, 10.0, "foo", foobar = 10), + info = "Pairlist::push_back" ) + +# test.Pairlist.insert <- function(){ +expect_equal( runit_pl_insert(), + pairlist( 30.0, 1L, bla = "bla", 10.0, 20.0, "foobar" ), + info = "Pairlist::replace" ) + +# test.Pairlist.replace <- function(){ +expect_equal( runit_pl_replace(), + pairlist( first = 1, 20.0 , FALSE), info = "Pairlist::replace" ) + +# test.Pairlist.size <- function(){ +expect_equal( runit_pl_size(), 3L, info = "Pairlist::size()" ) + +# test.Pairlist.remove <- function(){ +expect_equal( runit_pl_remove_1(), pairlist(10.0, 20.0), info = "Pairlist::remove(0)" ) +expect_equal( runit_pl_remove_2(), pairlist(1L, 10.0), info = "Pairlist::remove(0)" ) +expect_equal( runit_pl_remove_3(), pairlist(1L, 20.0), info = "Pairlist::remove(0)" ) + +# test.Pairlist.square <- function(){ +expect_equal( runit_pl_square_1(), 10.0, info = "Pairlist::operator[] used as rvalue" ) +expect_equal( runit_pl_square_2(), pairlist(1L, "foobar", 1L) , info = "Pairlist::operator[] used as lvalue" ) + +# test.Formula <- function(){ +expect_equal( runit_formula_(), x ~ y + z, info = "Formula( string )" ) + +# test.Formula.SEXP <- function(){ +expect_equal( runit_formula_SEXP( x ~ y + z), x ~ y + z, info = "Formula( SEXP = formula )" ) +expect_equal( runit_formula_SEXP( "x ~ y + z" ), x ~ y + z, info = "Formula( SEXP = STRSXP )" ) +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_listof.R b/inst/tinytest/test_listof.R new file mode 100644 index 000000000..46ed68c8f --- /dev/null +++ b/inst/tinytest/test_listof.R @@ -0,0 +1,74 @@ + +## Copyright (C) 2014 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/ListOf.cpp") + +x <- list( c(1, 5), c(2, 6), c(3, 7) ) + +# test.ListOf.identity <- function() { +expect_identical(test_identity(setNames(x, c('a', 'b', 'c'))), setNames(x, c('a', 'b', 'c'))) + +# test.ListOf.lapply.sum <- function() { +x <- list( c(1, 5), c(2, 6), c(3, 7) ) +expect_identical( test_lapply_sum(x), lapply(x, sum) ) + +# test.ListOf.sapply.sum <- function() { +x <- list( c(1, 5), c(2, 6), c(3, 7) ) +expect_identical( test_sapply_sum(x), sapply(x, sum) ) + +# test.ListOf.assign <- function() { +x <- list( c(1, 5), c(2, 6), c(3, 7) ) +test_assign(x, 100, "apple") +expect_identical( x[[2]], 100 ) + +# test.ListOf.assign.names <- function() { +x <- setNames(list(1, 2, 3), c('a', 'b', 'c')) +test_assign_names(x) +expect_identical( x[["a"]], x[["b"]] ) + +# test.ListOf.arith <- function() { +expect_identical(test_add(list(1, 2, 3)), 6) +expect_identical(test_add_subtract(list(1, 2, 3)), 0) +expect_identical(test_mult( list(1, 2, 3) ), 6) +expect_identical(test_char( list("banana") ), list("apple")) + +# test.ListOf.assign.names <- function() { +expect_error(test_assign_names(list(alpha=1, beta=2, gamma=3))) + +# test.ListOf.sub.calls <- function() { +expect_equal(test_sub_calls( list(1, 2, 3) ), 3) + +# test.ListOf.nested <- function() { +expect_equal(test_nested_listof( list(list(1)) ), 1) + +# test.ListOf.convert.implicit <- function() { +expect_equal(test_return_IVList(list(1, 2, 3)), list(1L, 2L, 3L)) + +# test.ListOf.convert.fail <- function() { +expect_error(test_return_IVList(list("a", "b", "c"))) + +# test.ListOf.names <- function() { +l <- list(a = 1L, b = 2L, c = 3L) +expect_equal(listof_names(l), c("a", "b", "c")) + +# test.ListOf.attr.foo <- function() { +l <- list(a = 1L) +attr(l, "foo") <- "bar" +expect_equal(listof_attr_foo(l), "bar") diff --git a/inst/tinytest/test_matrix.R b/inst/tinytest/test_matrix.R new file mode 100644 index 000000000..772d80d2f --- /dev/null +++ b/inst/tinytest/test_matrix.R @@ -0,0 +1,259 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/Matrix.cpp") + +# test.List.column <- function() { +x <- matrix( 1:16+.5, nc = 4 ) +res <- runit_Row_Column_sugar( x ) +target <- list(x[1,], x[,1], x[2,], x[,2], x[2,] + x[,2]) +expect_equal( res, target, info = "column and row as sugar" ) + + +# test.NumericMatrix <- function(){ +x <- matrix( 1:16 + .5, ncol = 4 ) +expect_equal( matrix_numeric(x), sum(diag(x)), info = "matrix indexing" ) + +y <- as.vector( x ) +expect_error( matrix_numeric(y) , info = "not a matrix" ) + +# test.CharacterMatrix <- function(){ +x <- matrix( letters[1:16], ncol = 4 ) +expect_equal( matrix_character(x), paste( diag(x), collapse = "" ) ) + +# test.GenericMatrix <- function( ){ +g <- function(y){ + sapply( y, function(x) seq(from=x, to = 16) ) +} +x <- matrix( g(1:16), ncol = 4 ) +expect_equal( matrix_generic(x), g(diag(matrix(1:16,ncol=4))), info = "GenericMatrix" ) + +# test.IntegerMatrix.diag <- function(){ +expected <- matrix( 0L, nrow = 5, ncol = 5 ) +diag( expected ) <- 1L +expect_equal( matrix_integer_diag(), expected, info = "IntegerMatrix::diag" ) + +# test.CharacterMatrix.diag <- function(){ +expected <- matrix( "", nrow = 5, ncol = 5 ) +diag( expected ) <- "foo" +expect_equal( matrix_character_diag(), expected, info = "CharacterMatrix::diag" ) + +# test.NumericMatrix.Ctors <- function(){ +x <- matrix(0, 3, 3) +expect_equal( matrix_numeric_ctor1(), x, info = "matrix from single int" ) + +x <- matrix(0, 3, 3) +expect_equal( matrix_numeric_ctor2(), x, info = "matrix from two int" ) + +# test.IntegerVector.matrix.indexing <- function(){ +x <- matrix( 1:16, ncol = 4 ) +expect_equal( integer_matrix_indexing(x), sum(diag(x)), info = "matrix indexing" ) + +expect_equal( diag(integer_matrix_indexing_lhs(x)), 2*0:3, info = "matrix indexing lhs" ) + +y <- as.vector( x ) +expect_error( integer_matrix_indexing_lhs(y) , info = "not a matrix" ) + +# test.NumericMatrix.row <- function(){ +x <- matrix( 1:16 + .5, ncol = 4 ) +expect_equal( runit_NumericMatrix_row( x ), sum( x[1,] ), info = "iterating over a row" ) + +# test.NumericMatrix.row.const <- function(){ +x <- matrix( 1:16 + .5, ncol = 4 ) +expect_equal( runit_NumericMatrix_row_const( x ), sum( x[1,] ), info = "iterating over a row" ) + + +# test.CharacterMatrix.row <- function(){ +m <- matrix( letters, ncol = 2 ) +expect_equal( runit_CharacterMatrix_row(m), paste( m[1,], collapse = "" ), info = "CharacterVector::Row" ) + +# test.CharacterMatrix.row.const <- function(){ +m <- matrix( letters, ncol = 2 ) +expect_equal( runit_CharacterMatrix_row_const(m), paste( m[1,], collapse = "" ), info = "CharacterVector::Row" ) + +# test.List.row <- function(){ +m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) +dim( m ) <- c( 4, 4 ) +expect_equal( runit_GenericMatrix_row( m ), 1 + 0:3*4, info = "List::Row" ) + +# test.List.row.const <- function(){ +m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) +dim( m ) <- c( 4, 4 ) +expect_equal( runit_GenericMatrix_row_const( m ), 1 + 0:3*4, info = "List::Row" ) + +# test.NumericMatrix.column <- function(){ +x <- matrix( 1:16 + .5, ncol = 4 ) +expect_equal( runit_NumericMatrix_column( x ), sum( x[,1] ) , info = "iterating over a column" ) + +# test.NumericMatrix.column.const <- function(){ +x <- matrix( 1:16 + .5, ncol = 4 ) +expect_equal( runit_NumericMatrix_column_const( x ), sum( x[,1] ) , info = "iterating over a column" ) + +# test.NumericMatrix.cumsum <- function(){ +x <- matrix( 1:8 + .5, ncol = 2 ) +expect_equal( runit_NumericMatrix_cumsum( x ), t(apply(x, 1, cumsum)) , info = "cumsum" ) + +# test.CharacterMatrix.column <- function(){ +m <- matrix( letters, ncol = 2 ) +expect_equal( runit_CharacterMatrix_column(m), paste( m[,1], collapse = "" ), info = "CharacterVector::Column" ) + +# test.CharacterMatrix.column.const <- function(){ +m <- matrix( letters, ncol = 2 ) +expect_equal( runit_CharacterMatrix_column_const(m), paste( m[,1], collapse = "" ), info = "CharacterVector::Column" ) + +# test.List.column <- function(){ +m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) +dim( m ) <- c( 4, 4 ) +expect_equal( runit_GenericMatrix_column( m ), 1:4, info = "List::Column" ) + +# test.List.column.const <- function(){ +m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) +dim( m ) <- c( 4, 4 ) +expect_equal( runit_GenericMatrix_column_const( m ), 1:4, info = "List::Column" ) + +# test.NumericMatrix.colsum <- function( ){ +probs <- matrix(1:12,nrow=3) +expect_equal( runit_NumericMatrix_colsum( probs ), t(apply(probs,1,cumsum)) ) + +# test.NumericMatrix.rowsum <- function( ){ +probs <- matrix(1:12,nrow=3) +expect_equal( runit_NumericMatrix_rowsum( probs ), apply(probs,2,cumsum) ) + +# test.NumericMatrix.SubMatrix <- function( ){ +target <- rbind( c(3,4,5,5), c(3,4,5,5), 0 ) +expect_equal( runit_SubMatrix(), target, info = "SubMatrix" ) + +# test.NumericMatrix.opequals <- function() { +m <- matrix(1:4, nrow=2) +expect_equal(m, matrix_opequals(m)) + +# test.NumericMatrix.rownames.colnames.proxy <- function() { +m <- matrix(as.numeric(1:4), nrow = 2) +runit_rownames_colnames_proxy(m, letters[1:2], LETTERS[1:2]) +expect_equal(rownames(m), letters[1:2]) +expect_equal(colnames(m), LETTERS[1:2]) +expect_error(runit_rownames_colnames_proxy(m, letters[1:3], letters[1:3])) +expect_error(runit_rownames_colnames_proxy(m, letters[1:2], NULL)) + +m <- matrix(as.numeric(1:9), nrow = 3) +runit_rownames_proxy(m) +expect_equal(rownames(m), c("A", "B", "C")) +expect_equal(colnames(m), NULL) + +# test.NumericMatrix.no.init <- function() { +m <- runit_no_init_matrix() +expect_equal(m, matrix(c(0, 1, 2, 3), nrow = 2)) + +# test.NumericMatrix.no.init.ctor <- function() { +m <- runit_no_init_matrix_ctor() +expect_equal(m, matrix(c(0, 1, 2, 3), nrow = 2)) + +# test.NumericMatrix.no.init.ctor.nrow <- function() { +nrow <- runit_no_init_matrix_ctor_nrow() +expect_equal(nrow, 2L) + +# test.NumericMatrix.const.Column <- function(){ +m <- matrix(as.numeric(1:9), nrow = 3) +res <- runit_const_Matrix_column(m) +expect_equal( m[,1], m[,2] ) + +# test.IntegerMatrix.accessor.with.bounds.checking <- function() { +m <- matrix(seq(1L, 12, by=1L), nrow=4L, ncol=3L) +expect_equal(mat_access_with_bounds_checking(m, 0, 0), 1) +expect_equal(mat_access_with_bounds_checking(m, 1, 2), 10) +expect_equal(mat_access_with_bounds_checking(m, 3, 2), 12) +expect_error(mat_access_with_bounds_checking(m, 4, 2) , info = "index out of bounds not detected" ) +expect_error(mat_access_with_bounds_checking(m, 3, 3) , info = "index out of bounds not detected" ) +expect_error(mat_access_with_bounds_checking(m, 3, -1) , info = "index out of bounds not detected" ) +expect_error(mat_access_with_bounds_checking(m, -1, 2) , info = "index out of bounds not detected" ) +expect_error(mat_access_with_bounds_checking(m, -1, -1) , info = "index out of bounds not detected" ) + +# test.IntegerMatrix.transpose <- function() { +M <- matrix(1:12, 3, 4) +expect_equal(transposeInteger(M), t(M), info="integer transpose") +rownames(M) <- letters[1:nrow(M)] +expect_equal(transposeInteger(M), t(M), info="integer transpose with rownames") +colnames(M) <- LETTERS[1:ncol(M)] +expect_equal(transposeInteger(M), t(M), info="integer transpose with row and colnames") + +# test.NumericMatrix.transpose <- function() { +M <- matrix(1.0 * (1:12), 3, 4) +expect_equal(transposeNumeric(M), t(M), info="numeric transpose") +rownames(M) <- letters[1:nrow(M)] +expect_equal(transposeNumeric(M), t(M), info="numeric transpose with rownames") +colnames(M) <- LETTERS[1:ncol(M)] +expect_equal(transposeNumeric(M), t(M), info="numeric transpose with row and colnames") + +# test.CharacterMatrix.transpose <- function() { +M <- matrix(as.character(1:12), 3, 4) +expect_equal(transposeCharacter(M), t(M), info="character transpose") +rownames(M) <- letters[1:nrow(M)] +expect_equal(transposeCharacter(M), t(M), info="character transpose with rownames") +colnames(M) <- LETTERS[1:ncol(M)] +expect_equal(transposeCharacter(M), t(M), info="character transpose with row and colnames") + +# test.Matrix.Scalar.op <- function() { +M <- matrix(c(1:12), 3, 4) +expect_equal(matrix_scalar_plus(M, 2), M + 2, info="matrix + scalar") +expect_equal(matrix_scalar_plus2(M, 2), 2 + M, info="scalar + matrix") +expect_equal(matrix_scalar_plus3(M, 2), M, info="matrix + scalar should not change input matrix") +expect_equal(matrix_scalar_plus4(M, 2), M, info="scalar + matrix should not change input matrix") + +expect_equal(matrix_scalar_divide(M, 2), M / 2, info="matrix / scalar") +expect_equal(matrix_scalar_divide2(M, 2), 2 / M, info="scalar / matrix") +expect_equal(matrix_scalar_divide3(M, 2), M, info="matrix / scalar should not change input matrix") +expect_equal(matrix_scalar_divide4(M, 2), M, info="scalar / matrix should not change input matrix") + +## 23 October 2016 +## eye function +# test.Matrix.eye <- function() { +expect_equal(dbl_eye(3), diag(1.0, 3, 3), info = "eye - numeric") +expect_equal(int_eye(3), diag(1L, 3, 3), info = "eye - integer") +expect_equal(cx_eye(3), diag(1.0 + 0i, 3, 3), info = "eye - complex") + +## diag(TRUE, 3, 3) was registering as +## a numeric matrix on Travis for some reason +mat <- matrix(FALSE, 3, 3) +diag(mat) <- TRUE +expect_equal(lgl_eye(3), mat, info = "eye - logical") + +## ones function +# test.Matrix.ones <- function() { +expect_equal(dbl_ones(3), matrix(1.0, 3, 3), info = "ones - numeric") +expect_equal(int_ones(3), matrix(1L, 3, 3), info = "ones - integer") +expect_equal(cx_ones(3), matrix(1.0 + 0i, 3, 3), info = "ones - complex") +expect_equal(lgl_ones(3), matrix(TRUE, 3, 3), info = "ones - logical") + +## zeros function +# test.Matrix.zeros <- function() { +expect_equal(dbl_zeros(3), matrix(0.0, 3, 3), info = "zeros - numeric") +expect_equal(int_zeros(3), matrix(0L, 3, 3), info = "zeros - integer") +expect_equal(cx_zeros(3), matrix(0.0 + 0i, 3, 3), info = "zeros - complex") +expect_equal(lgl_zeros(3), matrix(FALSE, 3, 3), info = "zeros - logical") + +# test.Matrix.diagfill <- function() { +expect_equal(num_diag_fill(diag(1.0, 2, 4), 0.0), matrix(0.0, 2, 4), info = "diagonal fill - case: n < p") +expect_equal(num_diag_fill(diag(1.0, 4, 2), 0.0), matrix(0.0, 4, 2), info = "diagonal fill - case: n > p") +expect_equal(num_diag_fill(diag(1.0, 3, 3), 0.0), matrix(0.0, 3, 3), info = "diagonal fill - case: n = p") + +m <- matrix("", 2, 4) +diag(m) <- letters[1:2] + +expect_equal(char_diag_fill(m, ""), matrix("", 2, 4), info = "diagonal fill - char") diff --git a/inst/tinytest/test_misc.R b/inst/tinytest/test_misc.R new file mode 100644 index 000000000..9fb5f50d9 --- /dev/null +++ b/inst/tinytest/test_misc.R @@ -0,0 +1,193 @@ + +## Copyright (C) 2010 - 2021 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/misc.cpp") + +# test.Symbol <- function(){ +res <- symbol_() +expect_true( res[1L], info = "Symbol creation - SYMSXP " ) +expect_true( res[2L], info = "Symbol creation - CHARSXP " ) +expect_true( res[3L], info = "Symbol creation - STRSXP " ) +expect_true( res[4L], info = "Symbol creation - std::string " ) + +# test.Symbol.notcompatible <- function(){ +expect_error( symbol_ctor(symbol_ctor), info = "Symbol not compatible with function" ) +expect_error( symbol_ctor(asNamespace("Rcpp")), info = "Symbol not compatible with environment" ) +expect_error( symbol_ctor(1:10), info = "Symbol not compatible with integer" ) +expect_error( symbol_ctor(TRUE), info = "Symbol not compatible with logical" ) +expect_error( symbol_ctor(1.3), info = "Symbol not compatible with numeric" ) +expect_error( symbol_ctor(as.raw(1) ), info = "Symbol not compatible with raw" ) + +# test.Argument <- function(){ +expect_equal( Argument_(), list( x = 2L, y = 3L ) , info = "Argument") + +# test.Dimension.const <- function(){ +expect_equal( Dimension_const( c(2L, 2L)) , 2L, info = "testing const operator[]" ) + +# test.evaluator.error <- function(){ +expect_error( evaluator_error(), info = "Rcpp_eval( stop() )" ) + +# test.evaluator.ok <- function(){ +expect_equal( sort(evaluator_ok(1:10)), 1:10, info = "Rcpp_eval running fine" ) + +# test.exceptions <- function(){ +can.demangle <- Rcpp:::capabilities()[["demangling"]] + +e <- tryCatch( exceptions_(), "C++Error" = function(e) e ) +expect_true( "C++Error" %in% class(e), info = "exception class C++Error" ) + +if( can.demangle ) expect_true( "std::range_error" %in% class(e), info = "exception class std::range_error" ) + +expect_equal( e$message, "boom", info = "exception message" ) + +if( can.demangle ){ + ## same with direct handler + e <- tryCatch( exceptions_(), "std::range_error" = function(e) e ) + expect_true( "C++Error" %in% class(e), info = "(direct handler) exception class C++Error" ) + expect_true( "std::range_error" %in% class(e), info = "(direct handler) exception class std::range_error" ) + expect_equal( e$message, "boom", info = "(direct handler) exception message" ) +} +f <- function(){ + try( exceptions_(), silent = TRUE) + "hello world" +} +expect_equal( f(), "hello world", info = "life continues after an exception" ) + + +# test.has.iterator <- function(){ +has_it <- has_iterator_() +expect_true( has_it[1L] , info = "has_iterator< std::vector >" ) +expect_true( has_it[2L] , info = "has_iterator< std::ist >" ) +expect_true( has_it[3L] , info = "has_iterator< std::deque >" ) +expect_true( has_it[4L] , info = "has_iterator< std::set >" ) +expect_true( has_it[5L] , info = "has_iterator< std::map >" ) + +expect_true( ! has_it[6L] , info = "has_iterator< std::pair >" ) +expect_true( ! has_it[7L] , info = "Rcpp::Symbol" ) + +# test.AreMacrosDefined <- function(){ +expect_true( Rcpp:::areMacrosDefined( "__cplusplus" ) ) + +# test.rcout <- function(){ +## define test string that is written to two files +teststr <- "First line.\nSecond line." + +rcppfile <- tempfile() +rfile <- tempfile() + +## write to test_rcpp.txt from Rcpp +test_rcout(rcppfile, teststr ) + +## write to test_r.txt from R +cat( teststr, file=rfile, sep='\n' ) + +## compare whether the two files have the same data +expect_equal( readLines(rcppfile), readLines(rfile), info="Rcout output") + +# test.rcout.complex <- function(){ +rcppfile <- tempfile() +rfile <- tempfile() + +z <- complex(real=sample(1:10, 1), imaginary=sample(1:10, 1)) + +## write to test_rcpp.txt from Rcpp +test_rcout_rcomplex(rcppfile, z ) + +## write to test_r.txt from R +cat( z, file=rfile, sep='\n' ) + +## compare whether the two files have the same data +expect_equal( readLines(rcppfile), readLines(rfile), info="Rcout Rcomplex") + +# test.na_proxy <- function(){ +expect_equal( + na_proxy(), + rep(c(TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE) , 2), + info = "Na_Proxy NA == handling" +) + +# test.StretchyList <- function(){ +expect_equal(stretchy_list(), pairlist( "foo", 1L, 3.2 )) + +# test.named_StretchyList <- function(){ +expect_equal(named_stretchy_list(), pairlist( a = "foo", b = 1L, c = 3.2 )) + +# test.stop.variadic <- function(){ +m <- tryCatch( test_stop_variadic(), error = function(e){ + conditionMessage(e) +}) +expect_equal( m, "foo 3" ) + +# test.NullableForNull <- function() { +M <- matrix(1:4, 2, 2) +expect_true( testNullableForNull(NULL) ) +expect_true( ! testNullableForNull(M) ) + +# test.NullableForNotNull <- function() { +M <- matrix(1:4, 2, 2) +expect_true( ! testNullableForNotNull(NULL) ) +expect_true( testNullableForNotNull(M) ) + +# test.NullableAccessOperator <- function() { +M <- matrix(1:4, 2, 2) +expect_equal( testNullableOperator(M), M ) + +# test.NullableAccessGet <- function() { +M <- matrix(1:4, 2, 2) +expect_equal( testNullableGet(M), M ) + +# test.NullableAccessAs <- function() { +M <- matrix(1:4, 2, 2) +expect_equal( testNullableAs(M), M ) + +# test.NullableAccessClone <- function() { +M <- matrix(1:4, 2, 2) +expect_equal( testNullableClone(M), M ) + +# test.NullableIsUsableTrue <- function() { +M <- matrix(1:4, 2, 2) +expect_equal( testNullableIsUsable(M), M) + +# test.NullableIsUsableFalse <- function() { +expect_true(is.null(testNullableIsUsable(NULL))) + +# test.NullableString <- function() { +expect_equal(testNullableString(), "") +expect_equal(testNullableString("blah"), "blah") + +# test.bib <- function() { +expect_true(nchar(Rcpp:::bib()) > 0, info="bib file") + +# test.getRcppVersion <- function() { +expect_true(inherits(Rcpp::getRcppVersion(), "package_version"), info="package_version object") +expect_true(Rcpp::getRcppVersion(devel=TRUE) >= Rcpp::getRcppVersion(devel=FALSE), info="dev greater equal release") + +## if need be it can be useful to fail to test e.g. the Docker setup +## commented out now as we prefer to pass when not debugging ;-) +# expect_true(FALSE, info="oh noes") + +## test that a message is output as is, and a suppressedMessage is not +txt <- "ABCdef" +expect_equal(capture.output(messageWrapper(txt), type="message"), txt) +expect_equal(capture.output(suppressMessages(messageWrapper(txt)), type="message"), character()) +expect_message(messageWrapper(txt)) +## test for message component +msg <- tryCatch(message(txt), message = identity) +expect_equal(msg$message, paste(txt, "\n", sep="")) diff --git a/inst/tinytest/test_modref.R b/inst/tinytest/test_modref.R new file mode 100644 index 000000000..dbc9cb499 --- /dev/null +++ b/inst/tinytest/test_modref.R @@ -0,0 +1,38 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/modref.cpp") + +# test.modRef <- function() { +ww <- new(ModRefWorld) +wg <- ModRefWorld$new() + +expect_equal(ww$greet(), wg$greet()) +wgg <- wg$greet() + +ww$set("Other") + +## test independence of ww, wg +expect_equal(ww$greet(), "Other") +expect_equal(wg$greet(), wgg) + +ModRefWorld$methods(twice = function() paste(greet(), greet())) + +expect_equal(ww$twice(), paste(ww$greet(), ww$greet())) diff --git a/inst/tinytest/test_module.R b/inst/tinytest/test_module.R new file mode 100644 index 000000000..960a33e96 --- /dev/null +++ b/inst/tinytest/test_module.R @@ -0,0 +1,108 @@ + +# Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +if( ! Rcpp:::capabilities()[["Rcpp modules"]] ) exit_file("Skipping as no Modules capability.") + +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" ) +expect_equal( w$greet(), "hello world" ) +w$set_ref( "hello world ref" ) +expect_equal( w$greet(), "hello world ref" ) +w$set_const_ref( "hello world const ref" ) +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 ) +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 ) +expect_equal( attr_Test_get_x_pointer(test), 3.0 ) + +# test.Module.property <- function(){ +w <- new( ModuleNum ) +expect_equal( w$x, 0.0 ) +expect_equal( w$y, 0L ) + +w$x <- 2.0 +expect_equal( w$x, 2.0 ) + +expect_error( { w$y <- 3 } ) + +# test.Module.member <- function(){ +w <- new( ModuleNumber ) +expect_equal( w$x, 0.0 ) +expect_equal( w$y, 0L ) + +w$x <- 2.0 +expect_equal( w$x, 2.0 ) + +expect_error( { w$y <- 3 } ) + +# test.Module.Constructor <- function() { +r <- new( ModuleRandomizer, 10.0, 20.0 ) +set.seed(123) +x10 <- runif(10, 10.0, 20.0) +set.seed(123) +expect_equal(r$get(10), x10) + +# test.Module.flexible.semantics <- function( ){ +expect_equal( test_reference( seq(0,10) ), 11L ) +expect_equal( test_const_reference( seq(0,10) ), 11L ) +expect_equal( test_const( seq(0,10) ), 11L ) diff --git a/inst/tinytest/test_module_client_package.R b/inst/tinytest/test_module_client_package.R new file mode 100644 index 000000000..08939342c --- /dev/null +++ b/inst/tinytest/test_module_client_package.R @@ -0,0 +1,62 @@ + +## Copyright (C) 2010 - 2019 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 . + +## The unit test in this file fails on OS X 10.5.* but pass on 10.6.* +## Sys.info release comes back with 10.* for the latter but 9.* for the former +## Thanks to Simon Urbanek and Baptiste Auguie for suggesting and testing this +.badOSX <- (Sys.info()['sysname'] == "Darwin" && + isTRUE(as.integer(gsub("\\..*","",Sys.info()['release'])) < 10L) ) + +## It now (Dec 2011) appears to fail on Windows too +.onWindows <- .Platform$OS.type == "windows" + +if (.badOSX || .onWindows) exit_file("Skipping as older macOS or Windows.") + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") + +## ## added test for 'testRcppClass' example of extending C++ classes via R +# test.Class.package <- function( ){ + +td <- tempfile() +cwd <- getwd() +dir.create( td ) +file.copy(system.file("tinytest", "testRcppClass", package = "Rcpp") , td, recursive = TRUE) +setwd( td ) +R <- shQuote( file.path( R.home( component = "bin" ), "R" )) +cmd <- paste( R , "CMD build testRcppClass" ) +system( cmd ) +dir.create( "templib" ) +install.packages( "testRcppClass_0.1.tar.gz", "templib", repos = NULL, type = "source" ) +require( "testRcppClass", "templib", character.only = TRUE ) + +v <- stdNumeric$new() +data <- as.numeric(1:10) +v$assign(data) +v$set(3L, v$at(3L) + 1) + +data[[4]] <- data[[4]] +1 + +expect_equal( v$as.vector(), data ) + +## a few function calls +expect_equal( bar(2), 4) +expect_equal( foo(2,3), 6) + +on.exit( { setwd( cwd) ; unlink( td, recursive = TRUE ) } ) diff --git a/inst/tinytest/test_na.R b/inst/tinytest/test_na.R new file mode 100644 index 000000000..d9c7cff2e --- /dev/null +++ b/inst/tinytest/test_na.R @@ -0,0 +1,30 @@ + +## Copyright (C) 2014 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/na.cpp") + +#test.na <- function() { +expect_identical( R_IsNA_(NA_real_), Rcpp_IsNA(NA_real_) ) +expect_identical( R_IsNA_(NA_real_+1), Rcpp_IsNA(NA_real_+1) ) +expect_identical( R_IsNA_(NA_real_+NaN), Rcpp_IsNA(NA_real_+NaN) ) +expect_identical( R_IsNA_(NaN+NA_real_), Rcpp_IsNA(NaN+NA_real_) ) +expect_identical( R_IsNaN_(NA_real_), Rcpp_IsNaN(NA_real_) ) +expect_identical( R_IsNaN_(NaN), Rcpp_IsNaN(NaN) ) +expect_identical( R_IsNaN_(NaN+1), Rcpp_IsNaN(NaN+1) ) diff --git a/inst/tinytest/test_packageversion.R b/inst/tinytest/test_packageversion.R new file mode 100644 index 000000000..871510d5e --- /dev/null +++ b/inst/tinytest/test_packageversion.R @@ -0,0 +1,50 @@ + +## Copyright (C) 2019 - 2024 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/rcppversion.cpp") + +## we take packageVersion, make it a character variable, split it by dots and turn it to ints +## note that v could now be a three or four element vector depending on what the package version is +pv <- packageVersion("Rcpp") +pvstr <- as.character(pv) +v <- as.integer(unlist(strsplit(pvstr, "\\."))) + +## construct a release string from the first three elements, ie "1.0.3" from 1.0.3.1 +relstr <- as.character(as.package_version(paste(v[1:3], collapse="."))) + +## call C++ function returning list of six values, three each for 'release' and 'dev' version +res <- checkVersion(v[1:min(4, length(v))]) + + +## basic check: is the #defined version equal to the computed version (issue #1014) +expect_equal(res$cur_ver, res$def_ver, info="current computed version equal defined version") + +## basic check: is the #defined string version equal to the computed string version (adjusting for rel) +expect_equal(relstr, res$def_str, info="current computed version equal defined dev string") + +## additional checks if we are a dev version +if (length(v) >= 4) { + expect_equal(res$cur_dev_ver, res$def_dev_ver, info="current computed dev version greater equal defined dev version") +} + +if (length(v) <= 4) { + ## basic check: is #defined string version equal to computed string + expect_true(grepl(pvstr, res$def_dev_str), info="current computed version equal defined dev string") +} diff --git a/inst/tinytest/test_quickanddirty.R b/inst/tinytest/test_quickanddirty.R new file mode 100644 index 000000000..ddbd0261a --- /dev/null +++ b/inst/tinytest/test_quickanddirty.R @@ -0,0 +1,49 @@ + +## Copyright (C) 2012 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/rmath.cpp") + +#test.rmath.norm <- function() { +x <- 0.25 +a <- 1.25 +b <- 2.50 +expect_equal(runit_dnorm(x, a, b), + c(dnorm(x, a, b, log=FALSE), dnorm(x, a, b, log=TRUE)), + info = " rmath.dnorm") + +expect_equal(runit_pnorm(x, a, b), + c(pnorm(x, a, b, lower=TRUE, log=FALSE), pnorm(log(x), a, b, lower=TRUE, log=TRUE), + pnorm(x, a, b, lower=FALSE, log=FALSE), pnorm(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pnorm") + +expect_equal(runit_qnorm(x, a, b), + c(qnorm(x, a, b, lower=TRUE, log=FALSE), qnorm(log(x), a, b, lower=TRUE, log=TRUE), + qnorm(x, a, b, lower=FALSE, log=FALSE), qnorm(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qnorm") + +set.seed(333) +rcpp_result <- runit_rnorm(a, b) +set.seed(333) +rcpp_result_sugar <- runit_rnorm_sugar(a, b) +set.seed(333) +r_result <- rnorm(5, a, b) + +expect_equal(rcpp_result, r_result, info = " rmath.rnorm") +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rnorm.sugar") diff --git a/inst/tinytest/test_rcpp_package_skeleton.R b/inst/tinytest/test_rcpp_package_skeleton.R new file mode 100644 index 000000000..6672d231b --- /dev/null +++ b/inst/tinytest/test_rcpp_package_skeleton.R @@ -0,0 +1,147 @@ + +## Copyright (C) 2013 - 2019 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 . + +.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" && Sys.getenv("RunVerboseRcppTests") == "yes" + +if (! .runThisTest) exit_file("Set 'RunVerboseRcppTests' and 'RunAllRcppTests' to 'yes' to run.") + +library(Rcpp) + +# test.Rcpp.package.skeleton <- function(){ + +tempdir <- tempdir() +path <- tempdir +pkg_path <- file.path(path, "foo") +R_path <- file.path(pkg_path, "R") +src_path <- file.path(pkg_path, "src") +env <- new.env() + +env$funA <- function(alpha, beta) "gamma" +env$funB <- function(first, ..., last) "foo" + +Rcpp.package.skeleton("foo", path=path, list=c("funA", "funB"), + author="Boo-Boo Bear", + maintainer="Yogi Bear", + license="An Opensource License", + email="yogibear@yogimail.com", + environment=env) + +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,] ) +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", + "we make sure that we 'link' to Rcpp (use its headers)" ) + +## make sure we have useDynLib in the namespace +NAMESPACE <- readLines( file.path(pkg_path, "NAMESPACE") ) + +## note: we use regular expressions anticipating a possible future +## usage of e.g. '.registration=TRUE' in Rcpp.package.skeleton +checkTrue( any(grepl( "useDynLib(foo", NAMESPACE, fixed=TRUE )), + "NAMESPACE has useDynLib(foo)" ) + +R_files <- list.files(R_path, full.names=TRUE) +checkTrue( all( c("funA.R", "funB.R") %in% list.files(R_path)), + "created R files from functions" ) +for (file in grep("RcppExports.R", R_files, invert=TRUE, value=TRUE)) { + code <- readLines(file) + fn <- eval(parse(text=paste(code, collapse="\n"))) + fn_name <- gsub(".*/(.*)\\.R$", "\\1", file) + checkIdentical(fn, base::get(fn_name), + sprintf("we parsed the function '%s' correctly", fn_name) + ) +} + +## make sure we can build the package as generated +## note: the generated .Rd placeholders are insufficient to be able +## to successfully install the pkg; e.g. I see + +## Error in Rd_info(db[[i]]) : +## missing/empty \title field in '/funA.Rd' +invisible(sapply( list.files( file.path(pkg_path, "man"), full.names=TRUE), unlink )) + +owd <- getwd() +setwd(path) +R <- shQuote( file.path( R.home( component = "bin" ), "R" )) +system( paste(R, "CMD build", pkg_path) ) +checkTrue( file.exists("foo_0.0.1.tar.gz"), "can successfully R CMD build the pkg") +dir.create("templib") +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) + + +# test.Rcpp.package.skeleton.Attributes <- function() { +tempdir <- tempdir() +path <- tempdir +if (dir.exists(file.path(path, "foo"))) unlink(file.path(path, "foo"), recursive=TRUE) +pkg_path <- file.path(path, "foo") +R_path <- file.path(pkg_path, "R") +src_path <- file.path(pkg_path, "src") + +Rcpp.package.skeleton("foo", path=path, attributes=TRUE, example_code=TRUE, + environment=environment()) +checkTrue(file.exists( file.path(src_path, "RcppExports.cpp")), + "RcppExports.cpp was created") +checkTrue(file.exists( file.path(src_path, "rcpp_hello_world.cpp")), + "rcpp_hello_world.cpp was created" ) +checkTrue(file.exists( file.path(R_path, "RcppExports.R")), + "RcppExports.R was created") +#on.exit( unlink(pkg_path, recursive=TRUE), add=TRUE ) +unlink(pkg_path, recursive=TRUE) + +# test.Rcpp.package.skeleton.NoAttributes <- function() { +tempdir <- tempdir() +path <- tempdir +pkg_path <- file.path(path, "foo") +R_path <- file.path(pkg_path, "R") +src_path <- file.path(pkg_path, "src") + +Rcpp.package.skeleton("foo", path=path, attributes=FALSE, example_code=TRUE, + environment=environment()) +checkTrue(file.exists( file.path(src_path, "rcpp_hello_world.cpp")), + "rcpp_hello_world.cpp was created") +checkTrue(file.exists( file.path(src_path, "rcpp_hello_world.h")), + "rcpp_hello_world.h was created") +checkTrue(file.exists( file.path(R_path, "rcpp_hello_world.R")), + "rcpp_hello_world.R was created" ) +on.exit( unlink(pkg_path, recursive=TRUE) ) + +# test.Rcpp.package.skeleton.Module <- function() { +tempdir <- tempdir() +path <- tempdir +pkg_path <- file.path(path, "foo") +R_path <- file.path(pkg_path, "R") +src_path <- file.path(pkg_path, "src") + +Rcpp.package.skeleton("foo", path=path, module=TRUE, environment=environment()) +checkTrue(file.exists( file.path(src_path, "rcpp_module.cpp")), + "rcpp_module.cpp was created") + +on.exit(unlink(pkg_path, recursive=TRUE)) +on.exit( setwd(owd), 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_reference.R b/inst/tinytest/test_reference.R new file mode 100644 index 000000000..7970f8b10 --- /dev/null +++ b/inst/tinytest/test_reference.R @@ -0,0 +1,29 @@ + +## Copyright (C) 2013 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/Reference.cpp") + +# test.Reference <- function(){ +Instrument <- setRefClass(Class="Instrument", fields=list("id"="character", "description"="character")) +Instrument$accessors(c("id", "description")) + +instrument <- Instrument$new(id="AAPL", description="Apple") + +expect_equal(runit_Reference_getId(instrument), "AAPL", msg = ".field") diff --git a/inst/tinytest/test_rmath.R b/inst/tinytest/test_rmath.R new file mode 100644 index 000000000..6ac42f693 --- /dev/null +++ b/inst/tinytest/test_rmath.R @@ -0,0 +1,625 @@ + +## Copyright (C) 2012 - 2016 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2016 - 2019 Dirk Eddelbuettel 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/rmath.cpp") + +# test.rmath.norm <- function() { +x <- 0.25 +a <- 1.25 +b <- 2.50 +expect_equal(runit_dnorm(x, a, b), + c(dnorm(x, a, b, log=FALSE), dnorm(x, a, b, log=TRUE)), + info = " rmath.dnorm") + +expect_equal(runit_pnorm(x, a, b), + c(pnorm(x, a, b, lower=TRUE, log=FALSE), pnorm(log(x), a, b, lower=TRUE, log=TRUE), + pnorm(x, a, b, lower=FALSE, log=FALSE), pnorm(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pnorm") + +expect_equal(runit_qnorm(x, a, b), + c(qnorm(x, a, b, lower=TRUE, log=FALSE), qnorm(log(x), a, b, lower=TRUE, log=TRUE), + qnorm(x, a, b, lower=FALSE, log=FALSE), qnorm(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qnorm") + +set.seed(333) +r_result <- rnorm(5, a, b) +set.seed(333) +rcpp_result <- runit_rnorm(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rnorm") + +set.seed(333) +rcpp_result_sugar <- runit_rnorm_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rnorm.sugar") + + +# test.rmath.unif <- function() { +x <- 0.25 +a <- 1.25 +b <- 2.50 +expect_equal(runit_dunif(x, a, b), + c(dunif(x, a, b, log=FALSE), dunif(x, a, b, log=TRUE)), + info = " rmath.dunif") + +expect_equal(runit_punif(x, a, b), + c(punif(x, a, b, lower=TRUE, log=FALSE), punif(log(x), a, b, lower=TRUE, log=TRUE), + punif(x, a, b, lower=FALSE, log=FALSE), punif(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.punif") + +expect_equal(runit_qunif(x, a, b), + c(qunif(x, a, b, lower=TRUE, log=FALSE), qunif(log(x), a, b, lower=TRUE, log=TRUE), + qunif(x, a, b, lower=FALSE, log=FALSE), qunif(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qunif") + +set.seed(333) +r_result <- runif(5, a, b) +set.seed(333) +rcpp_result <- runit_runif(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.runif") + +set.seed(333) +rcpp_result_sugar <- runit_runif_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.runif.sugar") + + +# test.rmath.gamma <- function() { +x <- 0.25 +a <- 1.0 +b <- 1.0 +expect_equal(runit_dgamma(x, a, b), + c(dgamma(x, a, b, log=FALSE), dgamma(x, a, b, log=TRUE)), + info = " rmath.dgamma") + +expect_equal(runit_pgamma(x, a, b), + c(pgamma(x, a, b, lower=TRUE, log=FALSE), pgamma(log(x), a, b, lower=TRUE, log=TRUE), + pgamma(x, a, b, lower=FALSE, log=FALSE), pgamma(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pgamma") + +expect_equal(runit_qgamma(x, a, b), + c(qgamma(x, a, b, lower=TRUE, log=FALSE), qgamma(log(x), a, b, lower=TRUE, log=TRUE), + qgamma(x, a, b, lower=FALSE, log=FALSE), qgamma(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qgamma") + +set.seed(333) +r_result <- rgamma(5, a, b) +set.seed(333) +rcpp_result <- runit_rgamma(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rgamma") + +set.seed(333) +rcpp_result_sugar <- runit_rgamma_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rgamma.sugar") + +# test.rmath.beta <- function() { +x <- 0.25 +a <- 0.8 +b <- 2.5 +expect_equal(runit_dbeta(x, a, b), + c(dbeta(x, a, b, log=FALSE), dbeta(x, a, b, log=TRUE)), + info = " rmath.dbeta") + +expect_equal(runit_pbeta(x, a, b), + c(pbeta(x, a, b, lower=TRUE, log=FALSE), pbeta(log(x), a, b, lower=TRUE, log=TRUE), + pbeta(x, a, b, lower=FALSE, log=FALSE), pbeta(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pbeta") + +expect_equal(runit_qbeta(x, a, b), + c(qbeta(x, a, b, lower=TRUE, log=FALSE), qbeta(log(x), a, b, lower=TRUE, log=TRUE), + qbeta(x, a, b, lower=FALSE, log=FALSE), qbeta(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qbeta") + +set.seed(333) +r_result <- rbeta(5, a, b) +set.seed(333) +rcpp_result <- runit_rbeta(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rbeta") + +set.seed(333) +rcpp_result_sugar <- runit_rbeta(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rbeta.sugar") + + +# test.rmath.lnorm <- function() { +x <- 0.25 +a <- 0.8 +b <- 2.5 +expect_equal(runit_dlnorm(x, a, b), + c(dlnorm(x, a, b, log=FALSE), dlnorm(x, a, b, log=TRUE)), + info = " rmath.dlnorm") + +expect_equal(runit_plnorm(x, a, b), + c(plnorm(x, a, b, lower=TRUE, log=FALSE), plnorm(log(x), a, b, lower=TRUE, log=TRUE), + plnorm(x, a, b, lower=FALSE, log=FALSE), plnorm(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.plnorm") + +expect_equal(runit_qlnorm(x, a, b), + c(qlnorm(x, a, b, lower=TRUE, log=FALSE), qlnorm(log(x), a, b, lower=TRUE, log=TRUE), + qlnorm(x, a, b, lower=FALSE, log=FALSE), qlnorm(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qlnorm") + +set.seed(333) +r_result <- rlnorm(5, a, b) +set.seed(333) +rcpp_result <- runit_rlnorm(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rlnorm") + +set.seed(333) +rcpp_result_sugar <- runit_rlnorm_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rlnorm.sugar") + + +# test.rmath.chisq <- function() { +x <- 0.25 +a <- 0.8 +expect_equal(runit_dchisq(x, a), + c(dchisq(x, a, log=FALSE), dchisq(x, a, log=TRUE)), + info = " rmath.dchisq") + +expect_equal(runit_pchisq(x, a), + c(pchisq(x, a, lower=TRUE, log=FALSE), pchisq(log(x), a, lower=TRUE, log=TRUE), + pchisq(x, a, lower=FALSE, log=FALSE), pchisq(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.pchisq") + +expect_equal(runit_qchisq(x, a), + c(qchisq(x, a, lower=TRUE, log=FALSE), qchisq(log(x), a, lower=TRUE, log=TRUE), + qchisq(x, a, lower=FALSE, log=FALSE), qchisq(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.qchisq") + +set.seed(333) +r_result <- rchisq(5, a) +set.seed(333) +rcpp_result <- runit_rchisq(a) +expect_equal(rcpp_result, r_result, info = " rmath.rchisq") + +set.seed(333) +rcpp_result_sugar <- runit_rchisq_sugar(a) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rchisq.sugar") + + +# test.rmath.nchisq <- function() { +x <- 0.25 +a <- 0.8 +b <- 2.5 +expect_equal(runit_dnchisq(x, a, b), + c(dchisq(x, a, b, log=FALSE), dchisq(x, a, b, log=TRUE)), + info = " rmath.dnchisq") + +expect_equal(runit_pnchisq(x, a, b), + c(pchisq(x, a, b, lower=TRUE, log=FALSE), pchisq(log(x), a, b, lower=TRUE, log=TRUE), + pchisq(x, a, b, lower=FALSE, log=FALSE), pchisq(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pnchisq") + +expect_equal(runit_qnchisq(x, a, b), + c(qchisq(x, a, b, lower=TRUE, log=FALSE), qchisq(log(x), a, b, lower=TRUE, log=TRUE), + qchisq(x, a, b, lower=FALSE, log=FALSE), qchisq(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qnchisq") + + +# test.rmath.f <- function() { +x <- 0.25 +a <- 0.8 +b <- 2.5 +expect_equal(runit_df(x, a, b), + c(df(x, a, b, log=FALSE), df(x, a, b, log=TRUE)), + info = " rmath.df") + +expect_equal(runit_pf(x, a, b), + c(pf(x, a, b, lower=TRUE, log=FALSE), pf(log(x), a, b, lower=TRUE, log=TRUE), + pf(x, a, b, lower=FALSE, log=FALSE), pf(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pf") + +expect_equal(runit_qf(x, a, b), + c(qf(x, a, b, lower=TRUE, log=FALSE), qf(log(x), a, b, lower=TRUE, log=TRUE), + qf(x, a, b, lower=FALSE, log=FALSE), qf(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qf") + +set.seed(333) +r_result <- rf(5, a, b) +set.seed(333) +rcpp_result <- runit_rf(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rf") + +set.seed(333) +rcpp_result_sugar <- runit_rf_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rf.sugar") +# } + + +# test.rmath.t <- function() { +x <- 0.25 +a <- 0.8 +expect_equal(runit_dt(x, a), + c(dt(x, a, log=FALSE), dt(x, a, log=TRUE)), + info = " rmath.dt") + +expect_equal(runit_pt(x, a), + c(pt(x, a, lower=TRUE, log=FALSE), pt(log(x), a, lower=TRUE, log=TRUE), + pt(x, a, lower=FALSE, log=FALSE), pt(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.pt") + +expect_equal(runit_qt(x, a), + c(qt(x, a, lower=TRUE, log=FALSE), qt(log(x), a, lower=TRUE, log=TRUE), + qt(x, a, lower=FALSE, log=FALSE), qt(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.qt") + +set.seed(333) +r_result <- rt(5, a) +set.seed(333) +rcpp_result <- runit_rt(a) +expect_equal(rcpp_result, r_result, info = " rmath.rt") + +set.seed(333) +rcpp_result_sugar <- runit_rt_sugar(a) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rt.sugar") + + +# test.rmath.binom <- function() { +x <- 5 +a <- 10 +b <- 0.5 +expect_equal(runit_dbinom(x, a, b), + c(dbinom(x, a, b, log=FALSE), dbinom(x, a, b, log=TRUE)), + info = " rmath.dbinom") + +expect_equal(runit_pbinom(x, a, b), + c(pbinom(x, a, b, lower=TRUE, log=FALSE), pbinom(log(x), a, b, lower=TRUE, log=TRUE), + pbinom(x, a, b, lower=FALSE, log=FALSE), pbinom(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pbinom") + +x <- x/a +expect_equal(runit_qbinom(x, a, b), + c(qbinom(x, a, b, lower=TRUE, log=FALSE), qbinom(log(x), a, b, lower=TRUE, log=TRUE), + qbinom(x, a, b, lower=FALSE, log=FALSE), qbinom(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qbinom") + +set.seed(333) +r_result <- rbinom(5, a, b) +set.seed(333) +rcpp_result <- runit_rbinom(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rbinom") + +set.seed(333) +rcpp_result_sugar <- runit_rbinom_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rbinom.sugar") + + +# test.rmath.cauchy <- function() { +x <- 0.25 +a <- 0.8 +b <- 2.5 +expect_equal(runit_dcauchy(x, a, b), + c(dcauchy(x, a, b, log=FALSE), dcauchy(x, a, b, log=TRUE)), + info = " rmath.dcauchy") + +expect_equal(runit_pcauchy(x, a, b), + c(pcauchy(x, a, b, lower=TRUE, log=FALSE), pcauchy(log(x), a, b, lower=TRUE, log=TRUE), + pcauchy(x, a, b, lower=FALSE, log=FALSE), pcauchy(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pcauchy") + +expect_equal(runit_qcauchy(x, a, b), + c(qcauchy(x, a, b, lower=TRUE, log=FALSE), qcauchy(log(x), a, b, lower=TRUE, log=TRUE), + qcauchy(x, a, b, lower=FALSE, log=FALSE), qcauchy(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qcauchy") + +set.seed(333) +r_result <- rcauchy(5, a, b) +set.seed(333) +rcpp_result <- runit_rcauchy(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rcauchy") + +set.seed(333) +rcpp_result_sugar <- runit_rcauchy_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rcauchy.sugar") + + +# test.rmath.exp <- function() { +x <- 0.25 +a <- 1.0 +expect_equal(runit_dexp(x, a), + c(dexp(x, a, log=FALSE), dexp(x, a, log=TRUE)), + info = " rmath.dexp") + +expect_equal(runit_pexp(x, a), + c(pexp(x, a, lower=TRUE, log=FALSE), pexp(log(x), a, lower=TRUE, log=TRUE), + pexp(x, a, lower=FALSE, log=FALSE), pexp(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.pexp") + +expect_equal(runit_qexp(x, a), + c(qexp(x, a, lower=TRUE, log=FALSE), qexp(log(x), a, lower=TRUE, log=TRUE), + qexp(x, a, lower=FALSE, log=FALSE), qexp(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.qexp") + +set.seed(333) +r_result <- rexp(5, a) +set.seed(333) +rcpp_result <- runit_rexp(a) +expect_equal(rcpp_result, r_result, info = " rmath.rexp") + +set.seed(333) +rcpp_result_sugar <- runit_rexp_sugar(a) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rexp.sugar") + + +# test.rmath.geom <- function() { +x <- 1 +a <- 0.75 +expect_equal(runit_dgeom(x, a), + c(dgeom(x, a, log=FALSE), dgeom(x, a, log=TRUE)), + info = " rmath.dgeom") + +expect_equal(runit_pgeom(x, a), + c(pgeom(x, a, lower=TRUE, log=FALSE), pgeom(log(x), a, lower=TRUE, log=TRUE), + pgeom(x, a, lower=FALSE, log=FALSE), pgeom(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.pgeom") + +expect_equal(runit_qgeom(x, a), + c(qgeom(x, a, lower=TRUE, log=FALSE), qgeom(log(x), a, lower=TRUE, log=TRUE), + qgeom(x, a, lower=FALSE, log=FALSE), qgeom(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.qgeom") + +set.seed(333) +r_result <- rgeom(5, a) +set.seed(333) +rcpp_result <- runit_rgeom(a) +expect_equal(rcpp_result, r_result, info = " rmath.rgeom") + +set.seed(333) +rcpp_result_sugar <- runit_rgeom_sugar(a) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rgeom.sugar") + +# test.rmath.hyper <- function() { +x <- 5 +a <- 10 +b <- 7 +c <- 8 +expect_equal(runit_dhyper(x, a, b, c), + c(dhyper(x, a, b, c, log=FALSE), dhyper(x, a, b, c, log=TRUE)), + info = " rmath.dhyper") + +expect_equal(runit_phyper(x, a, b, c), + c(phyper(x, a, b, c, lower=TRUE, log=FALSE), phyper(log(x), a, b, c, lower=TRUE, log=TRUE), + phyper(x, a, b, c, lower=FALSE, log=FALSE), phyper(log(x), a, b, c, lower=FALSE, log=TRUE)), + info = " rmath.phyper") + +x <- x/a +expect_equal(runit_qhyper(x, a, b, c), + c(qhyper(x, a, b, c, lower=TRUE, log=FALSE), qhyper(log(x), a, b, c, lower=TRUE, log=TRUE), + qhyper(x, a, b, c, lower=FALSE, log=FALSE), qhyper(log(x), a, b, c, lower=FALSE, log=TRUE)), + info = " rmath.qhyper") + +set.seed(333) +r_result <- rhyper(5, a, b, c) +set.seed(333) +rcpp_result <- runit_rhyper(a, b, c) +expect_equal(rcpp_result, r_result, info = " rmath.rhyper") + +set.seed(333) +rcpp_result_sugar <- runit_rhyper_sugar(a, b, c) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rhyper.sugar") + + +# test.rmath.nbinom <- function() { +x <- 2 +a <- 8 +b <- 0.25 +expect_equal(runit_dnbinom(x, a, b), + c(dnbinom(x, a, b, log=FALSE), dnbinom(x, a, b, log=TRUE)), + info = " rmath.dnbinom") + +expect_equal(runit_pnbinom(x, a, b), + c(pnbinom(x, a, b, lower=TRUE, log=FALSE), pnbinom(log(x), a, b, lower=TRUE, log=TRUE), + pnbinom(x, a, b, lower=FALSE, log=FALSE), pnbinom(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pnbinom") + +x <- x/a +expect_equal(runit_qnbinom(x, a, b), + c(qnbinom(x, a, b, lower=TRUE, log=FALSE), qnbinom(log(x), a, b, lower=TRUE, log=TRUE), + qnbinom(x, a, b, lower=FALSE, log=FALSE), qnbinom(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qnbinom") + +set.seed(333) +r_result <- rnbinom(5, a, b) +set.seed(333) +rcpp_result <- runit_rnbinom(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rnbinom") + +set.seed(333) +rcpp_result_sugar <- runit_rnbinom_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rnbinom.sugar") + + +# test.rmath.pois <- function() { +x <- 2 +a <- 1.0 +expect_equal(runit_dpois(x, a), + c(dpois(x, a, log=FALSE), dpois(x, a, log=TRUE)), + info = " rmath.dpois") + +expect_equal(runit_ppois(x, a), + c(ppois(x, a, lower=TRUE, log=FALSE), ppois(log(x), a, lower=TRUE, log=TRUE), + ppois(x, a, lower=FALSE, log=FALSE), ppois(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.ppois") + +x <- 1/x +expect_equal(runit_qpois(x, a), + c(qpois(x, a, lower=TRUE, log=FALSE), qpois(log(x), a, lower=TRUE, log=TRUE), + qpois(x, a, lower=FALSE, log=FALSE), qpois(log(x), a, lower=FALSE, log=TRUE)), + info = " rmath.qpois") + +set.seed(333) +r_result <- rpois(5, a) +set.seed(333) +rcpp_result <- runit_rpois(a) +expect_equal(rcpp_result, r_result, info = " rmath.rpois") + +set.seed(333) +rcpp_result_sugar <- runit_rpois_sugar(a) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rpois.sugar") + + +# test.rmath.weibull <- function() { +x <- 2 +a <- 8 +b <- 0.25 +expect_equal(runit_dweibull(x, a, b), + c(dweibull(x, a, b, log=FALSE), dweibull(x, a, b, log=TRUE)), + info = " rmath.dweibull") + +expect_equal(runit_pweibull(x, a, b), + c(pweibull(x, a, b, lower=TRUE, log=FALSE), pweibull(log(x), a, b, lower=TRUE, log=TRUE), + pweibull(x, a, b, lower=FALSE, log=FALSE), pweibull(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pweibull") + +x <- x/a +expect_equal(runit_qweibull(x, a, b), + c(qweibull(x, a, b, lower=TRUE, log=FALSE), qweibull(log(x), a, b, lower=TRUE, log=TRUE), + qweibull(x, a, b, lower=FALSE, log=FALSE), qweibull(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qweibull") + +set.seed(333) +r_result <- rweibull(5, a, b) +set.seed(333) +rcpp_result <- runit_rweibull(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rweibull") + +set.seed(333) +rcpp_result_sugar <- runit_rweibull_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rweibull.sugar") + + +# test.rmath.logis <- function() { +x <- 2 +a <- 8 +b <- 0.25 +expect_equal(runit_dlogis(x, a, b), + c(dlogis(x, a, b, log=FALSE), dlogis(x, a, b, log=TRUE)), + info = " rmath.dlogis") + +expect_equal(runit_plogis(x, a, b), + c(plogis(x, a, b, lower=TRUE, log=FALSE), plogis(log(x), a, b, lower=TRUE, log=TRUE), + plogis(x, a, b, lower=FALSE, log=FALSE), plogis(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.plogis") + +x <- x/a +expect_equal(runit_qlogis(x, a, b), + c(qlogis(x, a, b, lower=TRUE, log=FALSE), qlogis(log(x), a, b, lower=TRUE, log=TRUE), + qlogis(x, a, b, lower=FALSE, log=FALSE), qlogis(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qlogis") + +set.seed(333) +r_result <- rlogis(5, a, b) +set.seed(333) +rcpp_result <- runit_rlogis(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rlogis") + +set.seed(333) +rcpp_result_sugar <- runit_rlogis_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rlogis.sugar") + + +# test.rmath.nbeta <- function() { +x <- 5 +a <- 10 +b <- 7 +c <- 8 +expect_equal(runit_dnbeta(x, a, b, c), + c(dbeta(x, a, b, c, log=FALSE), dbeta(x, a, b, c, log=TRUE)), + info = " rmath.dnbeta") + +expect_equal(runit_pnbeta(x, a, b, c), + c(pbeta(x, a, b, c, lower=TRUE, log=FALSE), pbeta(log(x), a, b, c, lower=TRUE, log=TRUE), + pbeta(x, a, b, c, lower=FALSE, log=FALSE), pbeta(log(x), a, b, c, lower=FALSE, log=TRUE)), + info = " rmath.pnbeta") + +x <- x/a +expect_equal(runit_qnbeta(x, a, b, c), + c(qbeta(x, a, b, c, lower=TRUE, log=FALSE), qbeta(log(x), a, b, c, lower=TRUE, log=TRUE), + qbeta(x, a, b, c, lower=FALSE, log=FALSE), qbeta(log(x), a, b, c, lower=FALSE, log=TRUE)), + info = " rmath.qnbeta") + + +# test.rmath.nf <- function() { +x <- 5 +a <- 10 +b <- 7 +c <- 8 +expect_equal(runit_dnf(x, a, b, c), + c(df(x, a, b, c, log=FALSE), df(x, a, b, c, log=TRUE)), + info = " rmath.dnf") + +expect_equal(runit_pnf(x, a, b, c), + c(pf(x, a, b, c, lower=TRUE, log=FALSE), pf(log(x), a, b, c, lower=TRUE, log=TRUE), + pf(x, a, b, c, lower=FALSE, log=FALSE), pf(log(x), a, b, c, lower=FALSE, log=TRUE)), + info = " rmath.pnf") + +x <- x/a +expect_equal(runit_qnf(x, a, b, c), + c(qf(x, a, b, c, lower=TRUE, log=FALSE), qf(log(x), a, b, c, lower=TRUE, log=TRUE), + qf(x, a, b, c, lower=FALSE, log=FALSE), qf(log(x), a, b, c, lower=FALSE, log=TRUE)), + info = " rmath.qnf") + +# test.rmath.nt <- function() { +x <- 5 +a <- 10 +b <- 7 +expect_equal(runit_dnt(x, a, b), + c(dt(x, a, b, log=FALSE), dt(x, a, b, log=TRUE)), + info = " rmath.dnt") + +expect_equal(runit_pnt(x, a, b), + c(pt(x, a, b, lower=TRUE, log=FALSE), pt(log(x), a, b, lower=TRUE, log=TRUE), + pt(x, a, b, lower=FALSE, log=FALSE), pt(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pnt") + +x <- x/a +expect_equal(runit_qnt(x, a, b), + c(qt(x, a, b, lower=TRUE, log=FALSE), qt(log(x), a, b, lower=TRUE, log=TRUE), + qt(x, a, b, lower=FALSE, log=FALSE), qt(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qnt") + +# test.rmath.wilcox <- function() { +x <- 2 +a <- 4 +b <- 6 +expect_equal(runit_dwilcox(x, a, b), + c(dwilcox(x, a, b, log=FALSE), dwilcox(x, a, b, log=TRUE)), + info = " rmath.dwilcox") + +expect_equal(runit_pwilcox(x, a, b), + c(pwilcox(x, a, b, lower=TRUE, log=FALSE), pwilcox(log(x), a, b, lower=TRUE, log=TRUE), + pwilcox(x, a, b, lower=FALSE, log=FALSE), pwilcox(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.pwilcox") + +x <- x/a +expect_equal(runit_qwilcox(x, a, b), + c(qwilcox(x, a, b, lower=TRUE, log=FALSE), qwilcox(log(x), a, b, lower=TRUE, log=TRUE), + qwilcox(x, a, b, lower=FALSE, log=FALSE), qwilcox(log(x), a, b, lower=FALSE, log=TRUE)), + info = " rmath.qwilcox") + + +set.seed(333) +r_result <- rwilcox(5, a, b) +set.seed(333) +rcpp_result <- runit_rwilcox(a, b) +expect_equal(rcpp_result, r_result, info = " rmath.rwilcox") + +set.seed(333) +rcpp_result_sugar <- runit_rwilcox_sugar(a, b) +expect_equal(rcpp_result_sugar, r_result, info = " rmath.rwilcox_sugar") diff --git a/inst/tinytest/test_robject.R b/inst/tinytest/test_robject.R new file mode 100644 index 000000000..e6d38d817 --- /dev/null +++ b/inst/tinytest/test_robject.R @@ -0,0 +1,163 @@ + +## Copyright (C) 2009 - 2019 Romain Francois and 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/RObject.cpp") + +# test.RObject.asDouble <- function(){ +expect_equal( asDouble(2.123), 4.246, info = "as( REALSXP ) " ) +expect_equal( asDouble(2L), 4.0, info = "as( INTSXP ) " ) +expect_equal( asDouble(as.raw(2L)), 4.0, info = "as( RAWSXP )" ) +expect_error( asDouble('2'), info = "as( STRSXP ) -> exception" ) +expect_error( asDouble(2:3), info = "as expects the vector to be of length 1" ) + +# test.RObject.asInt <- function(){ +expect_equal( asInt(2.123), 4L, info = "as( REALSXP )" ) +expect_equal( asInt(2), 4L, info = "as( REALSXP )" ) +expect_equal( asInt(2L), 4.0, info = "as( INTSXP )" ) +expect_equal( asInt(as.raw(2L)), 4.0, info = "as( RAWSXP )" ) +expect_error( asInt( '2'), info = "as can not convert character" ) +expect_error( asInt( 2:3), info = "as expects the vector to be of length 1" ) + +# test.RObject.asStdString <- function(){ +expect_equal( asStdString("abc"), "abcabc", info = "as" ) +expect_error( asStdString(NULL), info = "as expects character vector" ) +expect_error( asStdString(0L), info = "as expects character vector" ) +expect_error( asStdString(0.1), info = "as expects character vector" ) +expect_error( asStdString(as.raw(0L)), info = "as expects character vector" ) + +expect_error( asStdString(letters), info = "as expects single string" ) + +# test.RObject.asRaw <- function(){ +expect_equal( asRaw(1L), as.raw(2L), info = "as(integer)" ) +expect_equal( asRaw(1.3), as.raw(2L), info = "as(numeric)" ) +expect_equal( asRaw(as.raw(1)), as.raw(2L), info = "as(raw)" ) +expect_error( asRaw(NULL) , info = "as(NULL) -> exception" ) +expect_error( asRaw("foo") , info = "as(character) -> exception" ) +expect_error( asRaw(1:2), info = "as(>1 integer) -> exception" ) +expect_error( asRaw(as.numeric(1:2)), info = "as(>1 numeric) -> exception" ) +expect_error( asRaw(as.raw(1:3)), info = "as(>1 raw) -> exception" ) +expect_error( asRaw(integer(0)), info = "as(0 integer) -> exception" ) +expect_error( asRaw(numeric(0)), info = "as(0 numeric) -> exception" ) +expect_error( asRaw(raw(0)), info = "as(0 raw) -> exception" ) + +# test.RObject.asLogical <- function(){ +expect_true( !asLogical(TRUE), info = "as(TRUE) -> true" ) +expect_true( asLogical(FALSE), info = "as(FALSE) -> false" ) +expect_true( !asLogical(1L), info = "as(1L) -> true" ) +expect_true( asLogical(0L), info = "as(0L) -> false" ) +expect_true( !asLogical(1.0), info = "as(1.0) -> true" ) +expect_true( asLogical(0.0), info = "as0.0) -> false" ) +expect_true( !asLogical(as.raw(1)), info = "as(aw.raw(1)) -> true" ) +expect_true( asLogical(as.raw(0)), info = "as(as.raw(0)) -> false" ) + +expect_error( asLogical(NULL), info = "as(NULL) -> exception" ) +expect_error( asLogical(c(TRUE,FALSE)), info = "as(>1 logical) -> exception" ) +expect_error( asLogical(1:2), info = "as(>1 integer) -> exception" ) +expect_error( asLogical(1:2+.1), info = "as(>1 numeric) -> exception" ) +expect_error( asLogical(as.raw(1:2)), info = "as(>1 raw) -> exception" ) + +expect_error( asLogical(integer(0)), info = "as(0 integer) -> exception" ) +expect_error( asLogical(numeric(0)), info = "as(0 numeric) -> exception" ) +expect_error( asLogical(raw(0)), info = "as(0 raw) -> exception" ) + +# test.RObject.asStdVectorInt <- function(){ +expect_equal( asStdVectorInt(x=2:5), 2:5*2L, info = "as< std::vector >(integer)" ) +expect_equal( asStdVectorInt(x=2:5+.1), 2:5*2L, info = "as< std::vector >(numeric)" ) +expect_equal( asStdVectorInt(x=as.raw(2:5)), 2:5*2L, info = "as< std::vector >(raw)" ) +expect_error( asStdVectorInt("foo"), info = "as< std::vector >(character) -> exception" ) +expect_error( asStdVectorInt(NULL), info = "as< std::vector >(NULL) -> exception" ) + +# test.RObject.asStdVectorDouble <- function(){ +expect_equal( asStdVectorDouble(x=0.1+2:5), 2*(0.1+2:5), info = "as< std::vector >( numeric )" ) +expect_equal( asStdVectorDouble(x=2:5), 2*(2:5), info = "as< std::vector >(integer)" ) +expect_equal( asStdVectorDouble(x=as.raw(2:5)), 2*(2:5), info = "as< std::vector >(raw)" ) +expect_error( asStdVectorDouble("foo"), info = "as< std::vector >(character) -> exception" ) +expect_error( asStdVectorDouble(NULL), info = "as< std::vector >(NULL) -> exception" ) + +# test.RObject.asStdVectorRaw <- function(){ +expect_equal( asStdVectorRaw(x=as.raw(0:9)), as.raw(2*(0:9)), info = "as< std::vector >(raw)" ) +expect_equal( asStdVectorRaw(x=0:9), as.raw(2*(0:9)), info = "as< std::vector >( integer )" ) +expect_equal( asStdVectorRaw(x=as.numeric(0:9)), as.raw(2*(0:9)), info = "as< std::vector >(numeric)" ) +expect_error( asStdVectorRaw("foo"), info = "as< std::vector >(character) -> exception" ) +expect_error( asStdVectorRaw(NULL), info = "as< std::vector >(NULL) -> exception" ) + +# test.RObject.asStdVectorBool <- function(){ +expect_equal( asStdVectorBool(x=c(TRUE,FALSE)), c(FALSE, TRUE), info = "as< std::vector >(logical)" ) +expect_equal( asStdVectorBool(x=c(1L, 0L)), c(FALSE, TRUE), info = "as< std::vector >(integer)" ) +expect_equal( asStdVectorBool(x=c(1.0, 0.0)), c(FALSE, TRUE), info = "as< std::vector >(numeric)" ) +expect_equal( asStdVectorBool(x=as.raw(c(1,0))), c(FALSE, TRUE), info = "as< std::vector >(raw)" ) +expect_error( asStdVectorBool("foo"), info = "as< std::vector >(character) -> exception" ) +expect_error( asStdVectorBool(NULL), info = "as< std::vector >(NULL) -> exception" ) + +# test.RObject.asStdVectorString <- function(){ +expect_equal( asStdVectorString(c("foo", "bar")), c("foofoo", "barbar"), info = "as< std::vector >(character)" ) +expect_error( asStdVectorString(1L), info = "as< std::vector >(integer) -> exception" ) +expect_error( asStdVectorString(1.0), info = "as< std::vector >(numeric) -> exception" ) +expect_error( asStdVectorString(as.raw(1)), info = "as< std::vector >(raw) -> exception" ) +expect_error( asStdVectorString(TRUE), info = "as< std::vector >(logical) -> exception" ) +expect_error( asStdVectorString(NULL), info = "as< std::vector >(NULL) -> exception" ) + +# test.RObject.stdsetint <- function(){ +expect_equal( stdsetint(), c(0L, 1L), info = "wrap( set )" ) + +# test.RObject.stdsetdouble <- function(){ +expect_equal( stdsetdouble(), as.numeric(0:1), info = "wrap( set" ) + +# test.RObject.stdsetraw <- function(){ +expect_equal( stdsetraw(), as.raw(0:1), info = "wrap(set)" ) + +# test.RObject.stdsetstring <- function(){ +expect_equal( stdsetstring(), c("bar", "foo"), info = "wrap(set)" ) + +# test.RObject.attributeNames <- function(){ +df <- data.frame( x = 1:10, y = 1:10 ) +expect_true( all( c("names","row.names","class") %in% attributeNames(df)), info = "RObject.attributeNames" ) + +# test.RObject.hasAttribute <- function(){ +df <- data.frame( x = 1:10 ) +expect_true( hasAttribute( df ), info = "RObject.hasAttribute" ) + +# test.RObject.attr <- function(){ +df <- data.frame( x = 1:150 ) +rownames(df) <- 1:150 +expect_equal( attr_( iris ), 1:150, info = "RObject.attr" ) + +# test.RObject.attr.set <- function(){ +expect_equal( attr(attr_set(), "foo"), 10L, info = "RObject.attr() = " ) + +# test.RObject.isNULL <- function(){ +df <- data.frame( x = 1:10 ) +expect_true( !isNULL( df ), info = "RObject.isNULL(data frame) -> false" ) +expect_true( !isNULL(1L), info = "RObject.isNULL(integer) -> false" ) +expect_true( !isNULL(1.0), info = "RObject.isNULL(numeric) -> false" ) +expect_true( !isNULL(as.raw(1)), info = "RObject.isNULL(raw) -> false" ) +expect_true( !isNULL(letters), info = "RObject.isNULL(character) -> false") +#expect_true( !isNULL(test.RObject.isNULL), info = "RObject.isNULL(function) -> false" ) +expect_true( !isNULL(base::ls), info = "RObject.isNULL(function) -> false" ) +expect_true( !isNULL(.GlobalEnv), info = "RObject.isNULL(environment) -> false" ) +expect_true( isNULL(NULL), info = "RObject.isNULL(NULL) -> true" ) + +# test.RObject.inherits <- function(){ +x <- 1:10 +expect_true( !inherits_(x) ) +class(x) <- "foo" +expect_true( inherits_(x) ) +class(x) <- c("foo", "bar" ) +expect_true( inherits_(x) ) diff --git a/inst/tinytest/test_s4.R b/inst/tinytest/test_s4.R new file mode 100644 index 000000000..dc632c828 --- /dev/null +++ b/inst/tinytest/test_s4.R @@ -0,0 +1,91 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/S4.cpp") + +# test.RObject.S4methods <- function(){ +setClass("track", representation(x="numeric", y="numeric")) +tr <- new( "track", x = 2, y = 2 ) +expect_equal(S4_methods(tr), list( TRUE, TRUE, FALSE, 2.0, 2.0 ), info = "slot management" ) + +S4_getslots( tr ) +expect_equal( tr@x, 10.0 , info = "slot('x') = 10" ) +expect_equal( tr@y, 20.0 , info = "slot('y') = 20" ) + +expect_error( S4_setslots( tr ), info = "slot does not exist" ) +expect_error( S4_setslots_2( tr ), info = "slot does not exist" ) + + + +# test.S4 <- function(){ +setClass("track", representation(x="numeric", y="numeric")) +tr <- new( "track", x = 2, y = 3 ) +expect_equal( S4_get_slot_x( tr ), 2, info = "S4( SEXP )" ) +expect_error( S4_get_slot_x( list( x = 2, y = 3 ) ), info = "not S4" ) +expect_error( S4_get_slot_x( structure( list( x = 2, y = 3 ), class = "track" ) ), info = "S3 is not S4" ) + +tr <- S4_ctor( "track" ) +expect_true( inherits( tr, "track" ) ) +expect_equal( tr@x, numeric(0) ) +expect_equal( tr@y, numeric(0) ) +expect_error( S4_ctor( "someclassthatdoesnotexist" ) ) + + +# test.S4.is <- function(){ +setClass("track", representation(x="numeric", y="numeric")) +setClass("trackCurve", representation(smooth = "numeric"), contains = "track") + +tr1 <- new( "track", x = 2, y = 3 ) +tr2 <- new( "trackCurve", x = 2, y = 3, smooth = 5 ) + +expect_true( S4_is_track( tr1 ), info = 'track is track' ) +expect_true( S4_is_track( tr2 ), info = 'trackCurve is track' ) + +expect_true( !S4_is_trackCurve( tr1 ), info = 'track is not trackCurve' ) +expect_true( S4_is_trackCurve( tr2 ), info = 'trackCurve is trackCurve' ) + + + +# test.Vector.SlotProxy.ambiguity <- function(){ +setClass("track", representation(x="numeric", y="numeric")) +setClass("trackCurve", representation(smooth = "numeric"), contains = "track") + +tr1 <- new( "track", x = 2, y = 3 ) +expect_equal( S4_get_slot_x(tr1), 2, info="Vector( SlotProxy ) ambiguity" ) + + + +# test.Vector.AttributeProxy.ambiguity <- function(){ +x <- 1:10 +attr( x, "foo" ) <- "bar" + +expect_equal( S4_get_attr_x(x), "bar", info="Vector( AttributeProxy ) ambiguity" ) + + + +# test.S4.dotdataslot <- function(){ +setClass( "Foo", contains = "character", representation( x = "numeric" ) ) +foo <- S4_dotdata( new( "Foo", "bla", x = 10 ) ) +expect_equal( as.character( foo) , "foooo" ) + +# test.S4.proxycoerce <- function() { +setClass("Foo", list(data="integer")) +foo <- new("Foo", data=1:3) +expect_equal( S4_proxycoerce(foo), c(1, 2, 3) ) diff --git a/inst/tinytest/test_stack.R b/inst/tinytest/test_stack.R new file mode 100644 index 000000000..5b23b7336 --- /dev/null +++ b/inst/tinytest/test_stack.R @@ -0,0 +1,156 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/stack.cpp") + +## On old versions of R, Rcpp_fast_eval() falls back to Rcpp_eval() and +## leaks on longjumps +hasUnwind <- getRversion() >= "3.5.0" +checkUnwound <- if (hasUnwind) expect_true else function(x) expect_identical(x, NULL) +checkErrorMessage <- function(x, msg) { + if (!hasUnwind) { + msg <- paste0("Evaluation error: ", msg, ".") + } + expect_identical(x$message, msg) +} +evalUnwind <- function(expr, indicator) { + testFastEval(expr, parent.frame(), indicator) +} + +## Wrap the unwind indicator in an environment because mutating +## vectors passed by argument can corrupt the R session in +## byte-compiled code. +newIndicator <- function() { + env <- new.env() + env$unwound <- NULL + env +} + +## Stack is always unwound on errors and interrupts +# test.stackUnwindsOnErrors <- function() { +indicator <- newIndicator() +out <- tryCatch(evalUnwind(quote(stop("err")), indicator), error = identity) +expect_true(indicator$unwound) +checkErrorMessage(out, "err") + + +# test.stackUnwindsOnInterrupts <- function() { +if (.Platform$OS.type != "windows") { + indicator <- newIndicator() + expr <- quote({ + repeat testSendInterrupt() + "returned" + }) + out <- tryCatch(evalUnwind(expr, indicator), interrupt = function(c) "onintr") + expect_true(indicator$unwound) + expect_identical(out, "onintr") +} + +# test.stackUnwindsOnCaughtConditions <- function() { +indicator <- newIndicator() +expr <- quote(signalCondition(simpleCondition("cnd"))) +cnd <- tryCatch(evalUnwind(expr, indicator), condition = identity) +expect_true(inherits(cnd, "simpleCondition")) +checkUnwound(indicator$unwound) + +# test.stackUnwindsOnRestartJumps <- function() { +indicator <- newIndicator() +expr <- quote(invokeRestart("rst")) +out <- withRestarts(evalUnwind(expr, indicator), rst = function(...) "restarted") +expect_identical(out, "restarted") +checkUnwound(indicator$unwound) + +# test.stackUnwindsOnReturns <- function() { +indicator <- newIndicator() +expr <- quote(signalCondition(simpleCondition(NULL))) +out <- callCC(function(k) { + withCallingHandlers(evalUnwind(expr, indicator), simpleCondition = function(e) k("jumped")) +}) +expect_identical(out, "jumped") +checkUnwound(indicator$unwound) + +# test.stackUnwindsOnReturnedConditions <- function() { +indicator <- newIndicator() +cnd <- simpleError("foo") +out <- tryCatch(evalUnwind(quote(cnd), indicator), error = function(c) "abort") +expect_true(indicator$unwound) + +## The old mechanism cannot differentiate between a returned error and a +## thrown error +if (hasUnwind) { + expect_identical(out, cnd) +} else { + expect_identical(out, "abort") +} + +## Longjump from the inner protected eval +# test.stackUnwindsOnNestedEvalsInner <- function() { +indicator1 <- newIndicator() +indicator2 <- newIndicator() +innerUnwindExpr <- quote(evalUnwind(quote(invokeRestart("here", "jump")), indicator2)) +out <- withRestarts( + here = identity, + evalUnwind(innerUnwindExpr, indicator1) +) + +expect_identical(out, "jump") +checkUnwound(indicator1$unwound) +checkUnwound(indicator2$unwound) + +## Longjump from the outer protected eval +# test.stackUnwindsOnNestedEvalsOuter <- function() { +indicator1 <- newIndicator() +indicator2 <- newIndicator() +innerUnwindExpr <- quote({ + evalUnwind(NULL, indicator2) + invokeRestart("here", "jump") +}) +out <- withRestarts(here = identity, evalUnwind(innerUnwindExpr, indicator1)) + +expect_identical(out, "jump") +checkUnwound(indicator1$unwound) +expect_true(indicator2$unwound) # Always unwound + +# test.unwindProtect <- function() { +if (hasUnwind) { + indicator <- newIndicator() + expect_error(testUnwindProtect(indicator, fail = TRUE)) + expect_true(indicator$unwound) + + indicator <- newIndicator() + expect_error(testUnwindProtectLambda(indicator, fail = TRUE)) + expect_true(indicator$unwound) + + indicator <- newIndicator() + expect_error(testUnwindProtectFunctionObject(indicator, fail = TRUE)) + expect_true(indicator$unwound) + + indicator <- newIndicator() + expect_equal(testUnwindProtect(indicator, fail = FALSE), 42) + expect_true(indicator$unwound) + + indicator <- newIndicator() + expect_equal(testUnwindProtectLambda(indicator, fail = FALSE), 42) + expect_true(indicator$unwound) + + indicator <- newIndicator() + expect_equal(testUnwindProtectFunctionObject(indicator, fail = FALSE), 420) + expect_true(indicator$unwound) +} diff --git a/inst/tinytest/test_stats.R b/inst/tinytest/test_stats.R new file mode 100644 index 000000000..4f51e8a3e --- /dev/null +++ b/inst/tinytest/test_stats.R @@ -0,0 +1,277 @@ + +## Copyright (C) 2010 - 2023 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/stats.cpp") + +# test.stats.dbeta <- function() { +vv <- seq(0, 1, by = 0.1) +a <- 0.5; b <- 2.5 +expect_equal(runit_dbeta(vv, a, b), + list(NoLog = dbeta(vv, a, b), Log = dbeta(vv, a, b, log=TRUE)), + info = " stats.qbeta") + +# test.stats.dbinom <- function( ){ +v <- 1:10 +expect_equal(runit_dbinom(v) , + list(false = dbinom(v, 10, .5), true = dbinom(v, 10, .5, TRUE )), info = "stats.dbinom" ) + +# test.stats.dunif <- function() { +vv <- seq(0, 1, by = 0.1) +expect_equal(runit_dunif(vv), + list(NoLog_noMin_noMax = dunif(vv), + NoLog_noMax = dunif(vv, 0), + NoLog = dunif(vv, 0, 1), + Log = dunif(vv, 0, 1, log=TRUE), + Log_noMax = dunif(vv, 0, log=TRUE) + ##,Log_noMin_noMax = dunif(vv, log=TRUE) ## wrong answer + ), + info = " stats.dunif") + +# test.stats.dgamma <- function( ) { +v <- 1:4 +expect_equal(runit_dgamma(v), + list(NoLog = dgamma(v, 1.0, 1.0), + Log = dgamma(v, 1.0, 1.0, log = TRUE ), + Log_noRate = dgamma(v, 1.0, log = TRUE )), + info = "stats.dgamma" ) + +# test.stats.dpois <- function( ){ +v <- 0:5 +expect_equal(runit_dpois(v) , + list( false = dpois(v, .5), true = dpois(v, .5, TRUE )), + info = "stats.dpois" ) + +# test.stats.dnorm <- function( ) { +v <- seq(0.0, 1.0, by=0.1) +expect_equal(runit_dnorm(v), + list(false_noMean_noSd = dnorm(v), + false_noSd = dnorm(v, 0.0), + false = dnorm(v, 0.0, 1.0), + true = dnorm(v, 0.0, 1.0, log=TRUE ), + true_noSd = dnorm(v, 0.0, log=TRUE ), + true_noMean_noSd = dnorm(v, log=TRUE )), + info = "stats.dnorm" ) + +# test.stats.dt <- function( ) { +v <- seq(0.0, 1.0, by=0.1) +expect_equal(runit_dt(v), + list(false = dt(v, 5), + true = dt(v, 5, log=TRUE ) # NB: need log=TRUE here + ), info = "stats.dt" ) + +# test.stats.pbeta <- function( ) { +a <- 0.5; b <- 2.5 +v <- qbeta(seq(0.0, 1.0, by=0.1), a, b) +expect_equal(runit_pbeta(v, a, b), + list(lowerNoLog = pbeta(v, a, b), + lowerLog = pbeta(v, a, b, log=TRUE), + upperNoLog = pbeta(v, a, b, lower=FALSE), + upperLog = pbeta(v, a, b, lower=FALSE, log=TRUE)), info = " stats.pbeta" ) +## Borrowed from R's d-p-q-r-tests.R +x <- c(.01, .10, .25, .40, .55, .71, .98) +pbval <- c(-0.04605755624088, -0.3182809860569, -0.7503593555585, + -1.241555830932, -1.851527837938, -2.76044482378, -8.149862739881) +expect_equal(runit_pbeta(x, 0.8, 2)$upperLog, pbval, info = " stats.pbeta") +expect_equal(runit_pbeta(1-x, 2, 0.8)$lowerLog, pbval, info = " stats.pbeta") + +# test.stats.pbinom <- function( ) { +n <- 20 +p <- 0.5 +vv <- 0:n +expect_equal(runit_pbinom(vv, n, p), + list(lowerNoLog = pbinom(vv, n, p), + lowerLog = pbinom(vv, n, p, log=TRUE), + upperNoLog = pbinom(vv, n, p, lower=FALSE), + upperLog = pbinom(vv, n, p, lower=FALSE, log=TRUE)), + info = " stats.pbinom") + +# test.stats.pcauchy <- function( ) { +location <- 0.5 +scale <- 1.5 +vv <- 1:5 +expect_equal(runit_pcauchy(vv, location, scale), + list(lowerNoLog = pcauchy(vv, location, scale), + lowerLog = pcauchy(vv, location, scale, log=TRUE), + upperNoLog = pcauchy(vv, location, scale, lower=FALSE), + upperLog = pcauchy(vv, location, scale, lower=FALSE, log=TRUE)), + info = " stats.pcauchy") + +# test.stats.punif <- function( ) { +v <- qunif(seq(0.0, 1.0, by=0.1)) +expect_equal(runit_punif(v), + list(lowerNoLog = punif(v), + lowerLog = punif(v, log=TRUE ), + upperNoLog = punif(v, lower=FALSE), + upperLog = punif(v, lower=FALSE, log=TRUE)), + info = "stats.punif" ) + # TODO: also borrow from R's d-p-q-r-tests.R + +# test.stats.pf <- function( ) { +v <- (1:9)/10 +expect_equal(runit_pf(v), + list(lowerNoLog = pf(v, 6, 8, lower=TRUE, log=FALSE), + lowerLog = pf(v, 6, 8, log=TRUE ), + upperNoLog = pf(v, 6, 8, lower=FALSE), + upperLog = pf(v, 6, 8, lower=FALSE, log=TRUE)), + info = "stats.pf" ) + +# test.stats.pnf <- function( ) { +v <- (1:9)/10 +expect_equal(runit_pnf(v), + list(lowerNoLog = pf(v, 6, 8, ncp=2.5, lower=TRUE, log=FALSE), + lowerLog = pf(v, 6, 8, ncp=2.5, log=TRUE ), + upperNoLog = pf(v, 6, 8, ncp=2.5, lower=FALSE), + upperLog = pf(v, 6, 8, ncp=2.5, lower=FALSE, log=TRUE)), + info = "stats.pnf" ) + +# test.stats.pchisq <- function( ) { +v <- (1:9)/10 +expect_equal(runit_pchisq(v), + list(lowerNoLog = pchisq(v, 6, lower=TRUE, log=FALSE), + lowerLog = pchisq(v, 6, log=TRUE ), + upperNoLog = pchisq(v, 6, lower=FALSE), + upperLog = pchisq(v, 6, lower=FALSE, log=TRUE)), + info = "stats.pchisq" ) + +# test.stats.pnchisq <- function( ) { +v <- (1:9)/10 +expect_equal(runit_pnchisq(v), + list(lowerNoLog = pchisq(v, 6, ncp=2.5, lower=TRUE, log=FALSE), + lowerLog = pchisq(v, 6, ncp=2.5, log=TRUE ), + upperNoLog = pchisq(v, 6, ncp=2.5, lower=FALSE), + upperLog = pchisq(v, 6, ncp=2.5, lower=FALSE, log=TRUE)), + info = "stats.pnchisq" ) + +# test.stats.pgamma <- function( ) { +v <- (1:9)/10 +expect_equal(runit_pgamma(v), + list(lowerNoLog = pgamma(v, shape = 2.0), + lowerLog = pgamma(v, shape = 2.0, log=TRUE ), + upperNoLog = pgamma(v, shape = 2.0, lower=FALSE), + upperLog = pgamma(v, shape = 2.0, lower=FALSE, log=TRUE)), + info = "stats.pgamma" ) + +# test.stats.pnorm <- function( ) { +v <- qnorm(seq(0.0, 1.0, by=0.1)) +expect_equal(runit_pnorm(v), + list(lowerNoLog = pnorm(v), + lowerLog = pnorm(v, log=TRUE ), + upperNoLog = pnorm(v, lower=FALSE), + upperLog = pnorm(v, lower=FALSE, log=TRUE)), + info = "stats.pnorm" ) +## Borrowed from R's d-p-q-r-tests.R +z <- c(-Inf,Inf,NA,NaN, rt(1000, df=2)) +z.ok <- z > -37.5 | !is.finite(z) +pz <- runit_pnorm(z) +expect_equal(pz$lowerNoLog, 1 - pz$upperNoLog, info = "stats.pnorm") +expect_equal(pz$lowerNoLog, runit_pnorm(-z)$upperNoLog, info = "stats.pnorm") +expect_equal(log(pz$lowerNoLog[z.ok]), pz$lowerLog[z.ok], info = "stats.pnorm") +## FIXME: Add tests that use non-default mu and sigma + +# test.stats.ppois <- function( ) { +vv <- 0:20 +expect_equal(runit_ppois(vv), + list(lowerNoLog = ppois(vv, 0.5), + lowerLog = ppois(vv, 0.5, log=TRUE), + upperNoLog = ppois(vv, 0.5, lower=FALSE), + upperLog = ppois(vv, 0.5, lower=FALSE, log=TRUE)), + info = " stats.ppois") + +# test.stats.pt <- function( ) { +v <- seq(0.0, 1.0, by=0.1) +expect_equal(runit_pt(v), + list(lowerNoLog = pt(v, 5), + lowerLog = pt(v, 5, log=TRUE), + upperNoLog = pt(v, 5, lower=FALSE), + upperLog = pt(v, 5, lower=FALSE, log=TRUE) ), + info = "stats.pt" ) + +# test.stats.pnt <- function( ) { +v <- seq(0.0, 1.0, by=0.1) +expect_equal(runit_pnt(v), + list(lowerNoLog = pt(v, 5, ncp=7), + lowerLog = pt(v, 5, ncp=7, log=TRUE), + upperNoLog = pt(v, 5, ncp=7, lower=FALSE), + upperLog = pt(v, 5, ncp=7, lower=FALSE, log=TRUE) ), + info = "stats.pnt" ) + +# test.stats.qbinom <- function( ) { +n <- 20 +p <- 0.5 +vv <- seq(0, 1, by = 0.1) +expect_equal(runit_qbinom_prob(vv, n, p), + list(lower = qbinom(vv, n, p), + upper = qbinom(vv, n, p, lower=FALSE)), + info = " stats.qbinom") + +# test.stats.qunif <- function( ) { +expect_equal(runit_qunif_prob(c(0, 1, 1.1, -.1)), + list(lower = c(0, 1, NaN, NaN), + upper = c(1, 0, NaN, NaN)), + info = "stats.qunif" ) + # TODO: also borrow from R's d-p-q-r-tests.R + +# test.stats.qnorm <- function( ) { +expect_equal(runit_qnorm_prob(c(0, 1, 1.1, -.1)), + list(lower = c(-Inf, Inf, NaN, NaN), + upper = c(Inf, -Inf, NaN, NaN)), + info = "stats.qnorm" ) +## Borrowed from R's d-p-q-r-tests.R and Wichura (1988) +expect_equal(runit_qnorm_prob(c( 0.25, .001, 1e-20))$lower, + c(-0.6744897501960817, -3.090232306167814, -9.262340089798408), + info = "stats.qnorm", + tol = 1e-15) + +expect_equal(runit_qnorm_log(c(-Inf, 0, 0.1)), + list(lower = c(-Inf, Inf, NaN), + upper = c(Inf, -Inf, NaN)), + info = "stats.qnorm" ) +## newer high-precision code in R 4.3.0 has slightly different value +## of -447.197893678525 so lowering tolerance a little +expect_equal(runit_qnorm_log(-1e5)$lower, -447.1974945, tolerance=1e-6) + +# test.stats.qpois.prob <- function( ) { +vv <- seq(0, 1, by = 0.1) +expect_equal(runit_qpois_prob(vv), + list(lower = qpois(vv, 0.5), + upper = qpois(vv, 0.5, lower=FALSE)), + info = " stats.qpois.prob") + +# test.stats.qt <- function( ) { +v <- seq(0.05, 0.95, by=0.05) +( x1 <- runit_qt(v, 5, FALSE, FALSE) ) +( x2 <- qt(v, df=5, lower=FALSE, log=FALSE) ) +expect_equal(x1, x2, info="stats.qt.f.f") + +( x1 <- runit_qt(v, 5, TRUE, FALSE) ) +( x2 <- qt(v, df=5, lower=TRUE, log=FALSE) ) +expect_equal(x1, x2, info="stats.qt.t.f") + +( x1 <- runit_qt(-v, 5, FALSE, TRUE) ) +( x2 <- qt(-v, df=5, lower=FALSE, log=TRUE) ) +expect_equal(x1, x2, info="stats.qt.f.t") + +( x1 <- runit_qt(-v, 5, TRUE, TRUE) ) +( x2 <- qt(-v, df=5, lower=TRUE, log=TRUE) ) +expect_equal(x1, x2, info="stats.qt.t.t") + + +## TODO: test.stats.qgamma +## TODO: test.stats.(dq)chisq diff --git a/inst/tinytest/test_string.R b/inst/tinytest/test_string.R new file mode 100644 index 000000000..6caa3d21c --- /dev/null +++ b/inst/tinytest/test_string.R @@ -0,0 +1,99 @@ + +## Copyright (C) 2012 - 2022 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/String.cpp") + +# test.replace_all <- function(){ +expect_equal( String_replace_all("abcdbacdab", "ab", "AB"), "ABcdbacdAB") + +# test.replace_first <- function(){ +expect_equal( String_replace_first("abcdbacdab", "ab", "AB"), "ABcdbacdab") + +# test.replace_last <- function(){ +expect_equal( String_replace_last("abcdbacdab", "ab", "AB"), "abcdbacdAB") + +# test.String.sapply <- function(){ +res <- test_sapply_string( "foobar", c("o", "a" ), c("*", "!" ) ) +expect_equal( res, "f**b!r" ) + +# test.compare.Strings <- function(){ +res <- test_compare_Strings( "aaa", "aab" ) +target <- list("a < b" = TRUE, + "a > b" = FALSE, + "a == b" = FALSE, + "a == a" = TRUE) +expect_equal( res, target ) + +# test.compare.String.string_proxy <- function(){ +v <- c("aab") +res <- test_compare_String_string_proxy( "aaa", v ) +target <- list("a == b" = FALSE, + "a != b" = TRUE, + "b == a" = FALSE, + "b != a" = TRUE) +expect_equal( res, target ) + +# test.compare.String.const_string_proxy <- function(){ +v <- c("aab") +res <- test_compare_String_const_string_proxy( "aaa", v ) +target <- list("a == b" = FALSE, + "a != b" = TRUE, + "b == a" = FALSE, + "b != a" = TRUE) +expect_equal( res, target ) + +# test.String.ctor <- function() { +res <- test_ctor("abc") +expect_identical(res, "abc") + +if (Rcpp:::capabilities()[["Full C++11 support"]]) { + ## test.String.move.ctor <- function() { + res <- test_move_ctor() + expect_identical(res, c("", "test")) + + ## test.String.move.std.string.ctor <- function() { + res <- test_move_std_string_ctor() + expect_identical(res, "test") + + ## test.String.move.assignment <- function() { + res <- test_move_assignment() + expect_identical(res, c("", "test")) + + ## test.String.move.std.string.assignment <- function() { + res <- test_move_std_string_assignment() + expect_identical(res, "test") +} + +# test.push.front <- function() { +res <- test_push_front("def") +expect_identical(res, "abcdef") + +# test.String.encoding <- function() { +a <- b <- "å" +Encoding(a) <- "unknown" +Encoding(b) <- "UTF-8" +expect_equal(test_String_encoding(a), 0) +expect_equal(test_String_encoding(b), 1) +expect_equal(Encoding(test_String_set_encoding(a)), "UTF-8") +expect_equal(Encoding(test_String_ctor_encoding(a)), "UTF-8") +expect_equal(Encoding(test_String_ctor_encoding2()), "UTF-8") + +# test.String.embeddedNul <- function() { +expect_error(test_String_embeddedNul()) diff --git a/inst/tinytest/test_subset.R b/inst/tinytest/test_subset.R new file mode 100644 index 000000000..526a9f131 --- /dev/null +++ b/inst/tinytest/test_subset.R @@ -0,0 +1,70 @@ + +## Copyright (C) 2014 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/Subset.cpp") + +# test.subset <- function() { + +x <- rnorm(5) +names(x) <- letters[1:5] + +expect_identical( x[c(1, 2, 3)], subset_test_int(x, c(0L, 1L, 2L)) ) +expect_error( subset_test_int(x, -1L) ) +expect_error( subset_test_int(x, length(x)) ) + +expect_identical( x[c(1, 2, 3)], subset_test_num(x, c(0, 1, 2)), "numeric subsetting") + +expect_identical( x[ c('b', 'a') ], subset_test_char(x, c('b', 'a')), "character subsetting") + +expect_error( subset_test_char( c(1, 2, 3), 'a' ), "names is null") + +lgcl <- c(TRUE, FALSE, TRUE, TRUE, FALSE) +expect_identical(x[lgcl], subset_test_lgcl(x, lgcl), "logical subsetting" ) + +names(x) <- c('a', 'b', 'b', 'c', 'd') +expect_identical(x['b'], subset_test_char(x, 'b'), "character subsetting -- duplicated name") + +l <- as.list(x) +expect_identical(l[c('b', 'c')], subset_test_list(x, c('b', 'c')), "list subsetting") + +expect_identical(x[ x > 0 ], subset_test_greater_0(x), "sugar subsetting (x[x > 0])") + +x <- as.numeric(-2:2) +expect_identical(c(-2, -1, 0, 0, 0), subset_test_assign(x)) + +attr(x, "foo") <- "bar" +y <- subset_test_int(x, 0L) +expect_identical( attr(y, "foo"), "bar" ) + +expect_identical(subset_assign_subset(1:6), c(0,0,0,4,5,6)) + +expect_identical(subset_assign_subset2(1:6), c(4,5,6,0,0,0)) + +expect_identical(subset_assign_subset3(1:6), c(4,4,4,0,0,0)) + +expect_identical(subset_assign_subset4(seq(2, 4, 0.2)), c(2L,2L,2L,2L,2L,3L,0L,0L,0L,0L,0L)) + +expect_error(subset_assign_subset5(1:6), info = "index error") + +expect_identical(subset_assign_vector_size_1(1:6,7), c(7,7,7,4,5,6)) + +x <- rnorm(10) +y <- sample(10, 5) +expect_identical(subset_sugar_add(x, y - 1L), x[y] + x[y]) diff --git a/inst/tinytest/test_sugar.R b/inst/tinytest/test_sugar.R new file mode 100644 index 000000000..4465cedf7 --- /dev/null +++ b/inst/tinytest/test_sugar.R @@ -0,0 +1,1638 @@ + +## Copyright (C) 2010 - 2025 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2025 Dirk Eddelbuettel, Romain Francois and 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/sugar.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 +## 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.abs <- function( ){ +x <- rnorm(10) +y <- -10:10 +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 (!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) ) ) + + +# test.sugar.all.one.greater <- function( ){ +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 (!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 (!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 ) ) + + + +# test.sugar.all.one.greater.or.equal <- function( ){ +fx <- runit_all_one_greater_or_equal +expect_true( ! fx( 1 ) ) +expect_true( ! fx( 1:10 ) ) +expect_true( fx( 6:10 ) ) +expect_true( fx( 5 ) ) +expect_true( ! fx( c(NA, 1) ) ) +if (!isArm) expect_true( is.na( fx( c(NA, 6) ) ) ) + + +# test.sugar.all.one.equal <- function( ){ +fx <- runit_all_one_equal +expect_true( ! fx( 1 ) ) +expect_true( ! fx( 1:2 ) ) +expect_true( fx( rep(5,4) ) ) +if (!isArm) expect_true( is.na( fx( c(5,NA) ) ) ) +expect_true(! fx( c(NA, 1) ) ) + + +# test.sugar.all.one.not.equal <- function( ){ +fx <- runit_all_not_equal_one +expect_true( fx( 1 ) ) +expect_true( fx( 1:2 ) ) +expect_true( ! fx( 5 ) ) +if (!isArm) expect_true( is.na( fx( c(NA, 1) ) ) ) +expect_true( ! fx( c(NA, 5) ) ) + + +# test.sugar.all.less <- function( ){ +fx <- runit_all_less +expect_true( ! fx( 1, 0 ) ) +expect_true( fx( 1:10, 2:11 ) ) +expect_true( fx( 0, 1 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.all.greater <- function( ){ +fx <- runit_all_greater +expect_true( fx( 1, 0 ) ) +expect_true( fx( 2:11, 1:10 ) ) +expect_true( ! fx( 0, 1 ) ) +expect_true( ! fx( 0:9, c(0:8,10) ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.all.less.or.equal <- function( ){ +fx <- runit_all_less_or_equal +expect_true( fx( 1, 1 ) ) +expect_true( ! fx( 1:2, c(1,1) ) ) +expect_true( fx( 0, 1 ) ) +expect_true( ! fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.all.greater.or.equal <- function( ){ +fx <- runit_all_greater_or_equal +expect_true( fx( 1, 1 ) ) +expect_true( fx( 1:2, c(1,1) ) ) +expect_true( ! fx( 0, 1 ) ) +expect_true( fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.all.equal <- function( ){ +fx <- runit_all_equal +expect_true( fx( 1, 1 ) ) +expect_true( ! fx( 1:2, c(1,1) ) ) +expect_true( ! fx( 0, 1 ) ) +expect_true( ! fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.all.not.equal <- function( ){ +fx <- runit_all_not_equal +expect_true( ! fx( 1, 1 ) ) +expect_true( ! fx( 1:2, c(1,1) ) ) +expect_true( fx( 0, 1 ) ) +expect_true( fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.any.less <- function( ){ +fx <- runit_any_less +expect_true( ! fx( 1, 0 ) ) +expect_true( fx( 1:10, 2:11 ) ) +expect_true( fx( 0, 1 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.any.greater <- function( ){ +fx <- runit_any_greater +expect_true( fx( 1, 0 ) ) +expect_true( fx( 2:11, 1:10 ) ) +expect_true( ! fx( 0, 1 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.any.less.or.equal <- function( ){ +fx <- runit_any_less_or_equal +expect_true( fx( 1, 1 ) ) +expect_true( fx( 1:2, c(1,1) ) ) +expect_true( fx( 0, 1 ) ) +expect_true( ! fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.any.greater.or.equal <- function( ){ +fx <- runit_any_greater_or_equal +expect_true( fx( 1, 1 ) ) +expect_true( fx( 1:2, c(1,1) ) ) +expect_true( ! fx( 0, 1 ) ) +expect_true( fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.any.equal <- function( ){ +fx <- runit_any_equal +expect_true( fx( 1, 1 ) ) +expect_true( fx( 1:2, c(1,1) ) ) +expect_true( ! fx( 0, 1 ) ) +expect_true( ! fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.any.not.equal <- function( ){ +fx <- runit_any_not_equal +expect_true( ! fx( 1, 1 ) ) +expect_true( fx( 1:2, c(1,1) ) ) +expect_true( fx( 0, 1 ) ) +expect_true( fx( 1, 0 ) ) +expect_true( is.na( fx( NA, 1 ) ) ) + + +# test.sugar.constructor <- function( ){ +fx <- runit_constructor +expect_equal( fx( 1, 0 ), FALSE ) +expect_equal( fx( 1:10, 2:11 ), rep(TRUE,10) ) +expect_equal( fx( 0, 1 ), TRUE ) +expect_true( identical( fx( NA, 1 ), NA ) ) + + +# test.sugar.assignment <- function( ){ +fx <- runit_assignment +expect_equal( fx( 1, 0 ), FALSE ) +expect_equal( fx( 1:10, 2:11 ), rep(TRUE,10) ) +expect_equal( fx( 0, 1 ), TRUE ) +expect_true( identical( fx( NA, 1 ), NA ) ) + + +# test.sugar.diff <- function( ){ +x <- as.integer(round(rnorm(100,1,100))) +expect_equal( runit_diff_int(x) , diff(x) ) +x <- rnorm( 100 ) +expect_equal( runit_diff(x) , diff(x) ) +y <- rnorm(100) +pred <- sample( c(T,F), 99, replace = TRUE ) +expect_equal( runit_diff_ifelse(pred, x, y ), ifelse( pred, diff(x), diff(y) ) ) + + +# test.sugar.exp <- function( ){ +fx <- runit_exp +x <- rnorm(10) +y <- -10:10 +expect_equal( fx(x,y) , list( exp(x), exp(y) ) ) + + +# test.sugar.floor <- function( ){ +fx <- runit_floor +x <- rnorm(10) +y <- -10:10 +expect_equal( fx(x,y) , list( floor(x), floor(y) ) ) + + +# test.sugar.ceil <- function( ){ +fx <- runit_ceil +x <- rnorm(10) +y <- -10:10 +expect_equal( fx(x,y) , list( ceiling(x), ceiling(y) ) ) + + +# test.sugar.pow <- function( ){ +fx <- runit_pow +x <- rnorm(10) +y <- -10:10 +expect_equal( fx(x,y) , list( x^3L , y^2.3 ) ) + + +# test.sugar.ifelse <- function( ){ +fx <- runit_ifelse +x <- 1:10 +y <- 10:1 +expect_equal(fx( x, y), + list("vec_vec" = ifelse( x x, x <= 2, 2 != x), info = "sugar vector scalar logical operations") + + +# test.vector.vector.ops <- function( ){ +x <- rnorm(10) +y <- runif(10) +expect_equal(vector_vector_ops(x,y), list(x + y, y - x, x * y, y / x), info = "sugar vector vector operations") + + +# test.vector.vector.logical <- function( ){ +x <- rnorm(10) +y <- runif(10) +expect_equal(vector_vector_logical(x,y), list(x < y, x > y, x <= y, x >= y, x == y, x != y), info = "sugar vector vector operations") + + +## Additions made 1 Jan 2015 + +# test.mean.integer <- function() { +v1 <- seq(-100L, 100L) +v2 <- c(v1, NA) +expect_equal(mean(v1), meanInteger(v1), info = "mean of integer vector") +expect_equal(mean(v2), meanInteger(v2), info = "mean of integer vector with NA") + + +# test.mean.numeric <- function() { +v1 <- seq(-100, 100) +v2 <- c(v1, NA) +v3 <- c(v1, Inf) +expect_equal(mean(v1), meanNumeric(v1), info = "mean of numeric vector") +expect_equal(mean(v2), meanNumeric(v2), info = "mean of numeric vector with NA") +expect_equal(mean(v3), meanNumeric(v3), info = "mean of numeric vector with Inf") + + +# test.mean.complex <- function() { +v1 <- seq(-100, 100) + 1.0i +v2 <- c(v1, NA) +v3 <- c(v1, Inf) +expect_equal(mean(v1), meanComplex(v1), info = "mean of complex vector") +expect_equal(mean(v2), meanComplex(v2), info = "mean of complex vector with NA") +expect_equal(mean(v3), meanComplex(v3), info = "mean of complex vector with Inf") + + +# test.mean.logical <- function() { +v1 <- c(rep(TRUE, 50), rep(FALSE, 25)) +v2 <- c(v1, NA) +expect_equal(mean(v1), meanLogical(v1), info = "mean of logical vector") +expect_equal(mean(v2), meanLogical(v2), info = "mean of logical vector with NA") + + + +## 30 Oct 2015: cumprod, cummin, cummax +## base::cumprod defined for numeric, integer, and complex vectors +# test.sugar.cumprod_nv <- function() { +fx <- runit_cumprod_nv +x <- rnorm(10) +expect_equal(fx(x), cumprod(x)) +x[4] <- NA +expect_equal(fx(x), cumprod(x)) + + +# test.sugar.cumprod_iv <- function() { +fx <- runit_cumprod_iv +x <- as.integer(rpois(10, 5)) +expect_equal(fx(x), cumprod(x)) +x[4] <- NA +expect_equal(fx(x), cumprod(x)) + + +# test.sugar.cumprod_cv <- function() { +fx <- runit_cumprod_cv +x <- rnorm(10) + 2i +expect_equal(fx(x), cumprod(x)) +x[4] <- NA +expect_equal(fx(x), cumprod(x)) + + +## base::cummin defined for numeric and integer vectors +# test.sugar.cummin_nv <- function() { +fx <- runit_cummin_nv +x <- rnorm(10) +expect_equal(fx(x), cummin(x)) +x[4] <- NA +expect_equal(fx(x), cummin(x)) + + +# test.sugar.cummin_iv <- function() { +fx <- runit_cummin_iv +x <- as.integer(rpois(10, 5)) +expect_equal(fx(x), cummin(x)) +x[4] <- NA +expect_equal(fx(x), cummin(x)) + + +## base::cummax defined for numeric and integer vectors +# test.sugar.cummax_nv <- function() { +fx <- runit_cummax_nv +x <- rnorm(10) +expect_equal(fx(x), cummax(x)) +x[4] <- NA +expect_equal(fx(x), cummax(x)) + + +# test.sugar.cummax_iv <- function() { +fx <- runit_cummax_iv +x <- as.integer(rpois(10, 5)) +expect_equal(fx(x), cummax(x)) +x[4] <- NA +expect_equal(fx(x), cummax(x)) + + + +## 18 January 2016: median +## median of integer vector +# test.sugar.median_int <- function() { +fx <- median_int + +x <- as.integer(rpois(5, 20)) +expect_equal(fx(x), median(x), info = "median_int / odd length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), median(x), info = "median_int / odd length / with NA / na.rm = FALSE") + +expect_equal(fx(x, TRUE), median(x, TRUE), info = "median_int / odd length / with NA / na.rm = TRUE") + +## +x <- as.integer(rpois(6, 20)) +expect_equal(fx(x), median(x), info = "median_int / even length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), median(x), info = "median_int / even length / with NA / na.rm = FALSE") + +expect_equal(fx(x, TRUE), median(x, TRUE), info = "median_int / even length / with NA / na.rm = TRUE") + + +## median of numeric vector +# test.sugar.median_dbl <- function() { +fx <- median_dbl + +x <- rnorm(5) +expect_equal(fx(x), median(x), info = "median_dbl / odd length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), median(x), info = "median_dbl / odd length / with NA / na.rm = FALSE") + +expect_equal(fx(x, TRUE), median(x, TRUE), info = "median_dbl / odd length / with NA / na.rm = TRUE") + +## +x <- rnorm(6) +expect_equal(fx(x), median(x), info = "median_dbl / even length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), median(x), info = "median_dbl / even length / with NA / na.rm = FALSE") + +expect_equal(fx(x, TRUE), median(x, TRUE), info = "median_dbl / even length / with NA / na.rm = TRUE") + + +## median of complex vector +# test.sugar.median_cx <- function() { +fx <- median_cx + +x <- rnorm(5) + 2i +expect_equal(fx(x), median(x), info = "median_cx / odd length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), median(x), info = "median_cx / odd length / with NA / na.rm = FALSE") + +expect_equal(fx(x, TRUE), median(x, TRUE), info = "median_cx / odd length / with NA / na.rm = TRUE") + +## +x <- rnorm(6) + 2i +expect_equal(fx(x), median(x), info = "median_cx / even length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), median(x), info = "median_cx / even length / with NA / na.rm = FALSE") + +expect_equal(fx(x, TRUE), median(x, TRUE), info = "median_cx / even length / with NA / na.rm = TRUE") + + +## median of character vector +# test.sugar.median_ch <- function() { +fx <- median_ch + +x <- sample(letters, 5) +expect_equal(fx(x), median(x), info = "median_ch / odd length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), median(x), info = "median_ch / odd length / with NA / na.rm = FALSE") + +## median(x, TRUE) returns NA_real_ for character vector input +## which results in a warning; i.e. if the vector it passes to +## `mean.default(sort(x, partial = half + 0L:1L)[half + 0L:1L])` +## has ((length(x) %% 2) == 0) + +expect_equal(fx(x, TRUE), as.character(suppressWarnings(median(x, TRUE))), info = "median_ch / odd length / with NA / na.rm = TRUE") + +## +x <- sample(letters, 6) +expect_equal(fx(x), as.character(suppressWarnings(median(x))), info = "median_ch / even length / no NA / na.rm = FALSE") + +x[4] <- NA +expect_equal(fx(x), as.character(suppressWarnings(median(x))), info = "median_ch / even length / with NA / na.rm = FALSE") + +expect_equal(fx(x, TRUE), as.character(suppressWarnings(median(x, TRUE))), info = "median_ch / even length / with NA / na.rm = TRUE") + + + +## 12 March 2016 +## cbind numeric tests +# test.sugar.cbind_numeric <- function() { + +m1 <- matrix(rnorm(9), 3, 3); m2 <- matrix(rnorm(9), 3, 3) +v1 <- rnorm(3); v2 <- rnorm(3) +s1 <- rnorm(1); s2 <- rnorm(1) + +cbind <- function(...) base::cbind(..., deparse.level = 0) + +expect_equal(n_cbind_mm(m1, m2), cbind(m1, m2), info = "numeric cbind / matrix matrix") + +expect_equal(n_cbind_mv(m1, v1), cbind(m1, v1), info = "numeric cbind / matrix vector") + +expect_equal(n_cbind_ms(m1, s1), cbind(m1, s1), info = "numeric cbind / matrix scalar") + +expect_equal(n_cbind_vv(v1, v2), cbind(v1, v2), info = "numeric cbind / vector vector") + +expect_equal(n_cbind_vm(v1, m1), cbind(v1, m1), info = "numeric cbind / vector matrix") + +expect_equal(n_cbind_vs(v1, s1), cbind(v1, s1), info = "numeric cbind / vector scalar") + +expect_equal(n_cbind_ss(s1, s2), cbind(s1, s2), info = "numeric cbind / scalar scalar") + +expect_equal(n_cbind_sm(s1, m1), cbind(s1, m1), info = "numeric cbind / scalar matrix") + +expect_equal(n_cbind_sv(s1, v1), cbind(s1, v1), info = "numeric cbind / scalar vector") + +expect_equal(n_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), info = "numeric cbind 9") + + + ## cbind integer tests +# test.sugar.cbind_integer <- function() { + +m1 <- matrix(rpois(9, 20), 3, 3); m2 <- matrix(rpois(9, 20), 3, 3) +v1 <- rpois(3, 30); v2 <- rpois(3, 30) +s1 <- rpois(1, 40); s2 <- rpois(1, 40) + +cbind <- function(...) base::cbind(..., deparse.level = 0) + +expect_equal(i_cbind_mm(m1, m2), cbind(m1, m2), info = "integer cbind / matrix matrix") + +expect_equal(i_cbind_mv(m1, v1), cbind(m1, v1), info = "integer cbind / matrix vector") + +expect_equal(i_cbind_ms(m1, s1), cbind(m1, s1), info = "integer cbind / matrix scalar") + +expect_equal(i_cbind_vv(v1, v2), cbind(v1, v2), info = "integer cbind / vector vector") + +expect_equal(i_cbind_vm(v1, m1), cbind(v1, m1), info = "integer cbind / vector matrix") + +expect_equal(i_cbind_vs(v1, s1), cbind(v1, s1), info = "integer cbind / vector scalar") + +expect_equal(i_cbind_ss(s1, s2), cbind(s1, s2), info = "integer cbind / scalar scalar") + +expect_equal(i_cbind_sm(s1, m1), cbind(s1, m1), info = "integer cbind / scalar matrix") + +expect_equal(i_cbind_sv(s1, v1), cbind(s1, v1), info = "integer cbind / scalar vector") + +expect_equal(i_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), info = "integer cbind 9") + + +## cbind complex tests +# test.sugar.cbind_complex <- function() { + +m1 <- matrix(rnorm(9), 3, 3) + 2i +m2 <- matrix(rnorm(9), 3, 3) + 5i +v1 <- rnorm(3) + 3i; v2 <- rnorm(3) + 4i +s1 <- rnorm(1) + 4i; s2 <- rnorm(1) + 5i + +cbind <- function(...) base::cbind(..., deparse.level = 0) + +expect_equal(cx_cbind_mm(m1, m2), cbind(m1, m2), info = "complex cbind / matrix matrix") + +expect_equal(cx_cbind_mv(m1, v1), cbind(m1, v1), info = "complex cbind / matrix vector") + +expect_equal(cx_cbind_ms(m1, s1), cbind(m1, s1), info = "complex cbind / matrix scalar") + +expect_equal(cx_cbind_vv(v1, v2), cbind(v1, v2), info = "complex cbind / vector vector") + +expect_equal(cx_cbind_vm(v1, m1), cbind(v1, m1), info = "complex cbind / vector matrix") + +expect_equal(cx_cbind_vs(v1, s1), cbind(v1, s1), info = "complex cbind / vector scalar") + +expect_equal(cx_cbind_ss(s1, s2), cbind(s1, s2), info = "complex cbind / scalar scalar") + +expect_equal(cx_cbind_sm(s1, m1), cbind(s1, m1), info = "complex cbind / scalar matrix") + +expect_equal(cx_cbind_sv(s1, v1), cbind(s1, v1), info = "complex cbind / scalar vector") + +expect_equal(cx_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), info = "complex cbind 9") + + + + ## cbind logical tests +# test.sugar.cbind_logical <- function() { + +m1 <- matrix(as.logical(rbinom(9, 1, .5)), 3, 3) +m2 <- matrix(as.logical(rbinom(9, 1, .5)), 3, 3) +v1 <- as.logical(rbinom(3, 1, .5)) +v2 <- as.logical(rbinom(3, 1, .5)) +s1 <- as.logical(rbinom(1, 1, .5)) +s2 <- as.logical(rbinom(1, 1, .5)) + +cbind <- function(...) base::cbind(..., deparse.level = 0) + +expect_equal(l_cbind_mm(m1, m2), cbind(m1, m2), info = "logical cbind / matrix matrix") + +expect_equal(l_cbind_mv(m1, v1), cbind(m1, v1), info = "logical cbind / matrix vector") + +expect_equal(l_cbind_ms(m1, s1), cbind(m1, s1), info = "logical cbind / matrix scalar") + +expect_equal(l_cbind_vv(v1, v2), cbind(v1, v2), info = "logical cbind / vector vector") + +expect_equal(l_cbind_vm(v1, m1), cbind(v1, m1), info = "logical cbind / vector matrix") + +expect_equal(l_cbind_vs(v1, s1), cbind(v1, s1), info = "logical cbind / vector scalar") + +expect_equal(l_cbind_ss(s1, s2), cbind(s1, s2), info = "logical cbind / scalar scalar") + +expect_equal(l_cbind_sm(s1, m1), cbind(s1, m1), info = "logical cbind / scalar matrix") + +expect_equal(l_cbind_sv(s1, v1), cbind(s1, v1), info = "logical cbind / scalar vector") + +expect_equal(l_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), info = "logical cbind 9") + + +## cbind character tests +# test.sugar.cbind_character <- function() { + +m1 <- matrix(sample(letters, 9, TRUE), 3, 3) +m2 <- matrix(sample(LETTERS, 9, TRUE), 3, 3) +v1 <- sample(letters, 3, TRUE) +v2 <- sample(LETTERS, 3, TRUE) + +cbind <- function(...) base::cbind(..., deparse.level = 0) + +expect_equal(c_cbind_mm(m1, m2), cbind(m1, m2), info = "logical cbind / matrix matrix") + +expect_equal(c_cbind_mv(m1, v1), cbind(m1, v1), info = "logical cbind / matrix vector") + +expect_equal(c_cbind_vv(v1, v2), cbind(v1, v2), info = "logical cbind / vector vector") + +expect_equal(c_cbind_vm(v1, m1), cbind(v1, m1), info = "logical cbind / vector matrix") + +expect_equal(c_cbind6(m1, v1, m2, v2, m1, v1), cbind(m1, v1, m2, v2, m1, v1), info = "character cbind 6") + + + +## 04 September 2016 +## {row,col}{Sums,Means} numeric tests +# test.sugar.rowMeans_numeric <- function() { + +x <- matrix(rnorm(9), 3) + +expect_equal(dbl_row_sums(x), rowSums(x), info = "numeric / rowSums / keep NA / clean input") +expect_equal(dbl_row_sums(x, TRUE), rowSums(x, TRUE), info = "numeric / rowSums / rm NA / clean input") +expect_equal(dbl_col_sums(x), colSums(x), info = "numeric / colSums / keep NA / clean input") +expect_equal(dbl_col_sums(x, TRUE), colSums(x, TRUE), info = "numeric / colSums / rm NA / clean input") + +expect_equal(dbl_row_means(x), rowMeans(x), info = "numeric / rowMeans / keep NA / clean input") +expect_equal(dbl_row_means(x, TRUE), rowMeans(x, TRUE), info = "numeric / rowMeans / rm NA / clean input") +expect_equal(dbl_col_means(x), colMeans(x), info = "numeric / colMeans / keep NA / clean input") +expect_equal(dbl_col_means(x, TRUE), colMeans(x, TRUE), info = "numeric / colMeans / rm NA / clean input") + +x[sample(1:9, 4)] <- NA + +expect_equal(dbl_row_sums(x), rowSums(x), info = "numeric / rowSums / keep NA / mixed input") +expect_equal(dbl_row_sums(x, TRUE), rowSums(x, TRUE), info = "numeric / rowSums / rm NA / mixed input") +expect_equal(dbl_col_sums(x), colSums(x), info = "numeric / colSums / keep NA / mixed input") +expect_equal(dbl_col_sums(x, TRUE), colSums(x, TRUE), info = "numeric / colSums / rm NA / mixed input") +expect_equal(dbl_row_means(x), rowMeans(x), info = "numeric / rowMeans / keep NA / mixed input") +expect_equal(dbl_row_means(x, TRUE), rowMeans(x, TRUE), info = "numeric / rowMeans / rm NA / mixed input") +expect_equal(dbl_col_means(x), colMeans(x), info = "numeric / colMeans / keep NA / mixed input") +expect_equal(dbl_col_means(x, TRUE), colMeans(x, TRUE), info = "numeric / colMeans / rm NA / mixed input") + +x[] <- NA_real_ + +expect_equal(dbl_row_sums(x), rowSums(x), info = "numeric / rowSums / keep NA / dirty input") +expect_equal(dbl_row_sums(x, TRUE), rowSums(x, TRUE), info = "numeric / rowSums / rm NA / dirty input") +expect_equal(dbl_col_sums(x), colSums(x), info = "numeric / colSums / keep NA / dirty input") +expect_equal(dbl_col_sums(x, TRUE), colSums(x, TRUE), info = "numeric / colSums / rm NA / dirty input") +expect_equal(dbl_row_means(x), rowMeans(x), info = "numeric / rowMeans / keep NA / dirty input") +expect_equal(dbl_row_means(x, TRUE), rowMeans(x, TRUE), info = "numeric / rowMeans / rm NA / dirty input") +expect_equal(dbl_col_means(x), colMeans(x), info = "numeric / colMeans / keep NA / dirty input") +expect_equal(dbl_col_means(x, TRUE), colMeans(x, TRUE), info = "numeric / colMeans / rm NA / dirty input") + +## {row,col}{Sums,Means} integer tests +# test.sugar.rowMeans_integer <- function() { + +x <- matrix(as.integer(rnorm(9) * 1e4), 3) + +expect_equal(int_row_sums(x), rowSums(x), info = "integer / rowSums / keep NA / clean input") +expect_equal(int_row_sums(x, TRUE), rowSums(x, TRUE), info = "integer / rowSums / rm NA / clean input") +expect_equal(int_col_sums(x), colSums(x), info = "integer / colSums / keep NA / clean input") +expect_equal(int_col_sums(x, TRUE), colSums(x, TRUE), info = "integer / colSums / rm NA / clean input") +expect_equal(int_row_means(x), rowMeans(x), info = "integer / rowMeans / keep NA / clean input") +expect_equal(int_row_means(x, TRUE), rowMeans(x, TRUE), info = "integer / rowMeans / rm NA / clean input") +expect_equal(int_col_means(x), colMeans(x), info = "integer / colMeans / keep NA / clean input") +expect_equal(int_col_means(x, TRUE), colMeans(x, TRUE), info = "integer / colMeans / rm NA / clean input") + + +x[sample(1:9, 4)] <- NA + +expect_equal(int_row_sums(x), rowSums(x), info = "integer / rowSums / keep NA / mixed input") +expect_equal(int_row_sums(x, TRUE), rowSums(x, TRUE), info = "integer / rowSums / rm NA / mixed input") +expect_equal(int_col_sums(x), colSums(x), info = "integer / colSums / keep NA / mixed input") +expect_equal(int_col_sums(x, TRUE), colSums(x, TRUE), info = "integer / colSums / rm NA / mixed input") +expect_equal(int_row_means(x), rowMeans(x), info = "integer / rowMeans / keep NA / mixed input") +expect_equal(int_row_means(x, TRUE), rowMeans(x, TRUE), info = "integer / rowMeans / rm NA / mixed input") +expect_equal(int_col_means(x), colMeans(x), info = "integer / colMeans / keep NA / mixed input") +expect_equal(int_col_means(x, TRUE), colMeans(x, TRUE), info = "integer / colMeans / rm NA / mixed input") + +x[] <- NA_integer_ + +expect_equal(int_row_sums(x), rowSums(x), info = "integer / rowSums / keep NA / dirty input") +expect_equal(int_row_sums(x, TRUE), rowSums(x, TRUE), info = "integer / rowSums / rm NA / dirty input") +expect_equal(int_col_sums(x), colSums(x), info = "integer / colSums / keep NA / dirty input") +expect_equal(int_col_sums(x, TRUE), colSums(x, TRUE), info = "integer / colSums / rm NA / dirty input") +expect_equal(int_row_means(x), rowMeans(x), info = "integer / rowMeans / keep NA / dirty input") +expect_equal(int_row_means(x, TRUE), rowMeans(x, TRUE), info = "integer / rowMeans / rm NA / dirty input") +expect_equal(int_col_means(x), colMeans(x), info = "integer / colMeans / keep NA / dirty input") +expect_equal(int_col_means(x, TRUE), colMeans(x, TRUE), info = "integer / colMeans / rm NA / dirty input") + +## {row,col}{Sums,Means} logical tests +# test.sugar.rowMeans_logical <- function() { + +x <- matrix(rbinom(9, 1, .5) > 0, 3) + +expect_equal(lgl_row_sums(x), rowSums(x), info = "logical / rowSums / keep NA / clean input") +expect_equal(lgl_row_sums(x, TRUE), rowSums(x, TRUE), info = "logical / rowSums / rm NA / clean input") + +expect_equal(lgl_col_sums(x), colSums(x), info = "logical / colSums / keep NA / clean input") +expect_equal(lgl_col_sums(x, TRUE), colSums(x, TRUE), info = "logical / colSums / rm NA / clean input") + +expect_equal(lgl_row_means(x), rowMeans(x), info = "logical / rowMeans / keep NA / clean input") +expect_equal(lgl_row_means(x, TRUE), rowMeans(x, TRUE), info = "logical / rowMeans / rm NA / clean input") + +expect_equal(lgl_col_means(x), colMeans(x), info = "logical / colMeans / keep NA / clean input") +expect_equal(lgl_col_means(x, TRUE), colMeans(x, TRUE), info = "logical / colMeans / rm NA / clean input") + + +x[sample(1:9, 4)] <- NA + +expect_equal(lgl_row_sums(x), rowSums(x), info = "logical / rowSums / keep NA / mixed input") +expect_equal(lgl_row_sums(x, TRUE), rowSums(x, TRUE), info = "logical / rowSums / rm NA / mixed input") + +expect_equal(lgl_col_sums(x), colSums(x), info = "logical / colSums / keep NA / mixed input") +expect_equal(lgl_col_sums(x, TRUE), colSums(x, TRUE), info = "logical / colSums / rm NA / mixed input") + +expect_equal(lgl_row_means(x), rowMeans(x), info = "logical / rowMeans / keep NA / mixed input") +expect_equal(lgl_row_means(x, TRUE), rowMeans(x, TRUE), info = "logical / rowMeans / rm NA / mixed input") + +expect_equal(lgl_col_means(x), colMeans(x), info = "logical / colMeans / keep NA / mixed input") +expect_equal(lgl_col_means(x, TRUE), colMeans(x, TRUE), info = "logical / colMeans / rm NA / mixed input") + + +x[] <- NA_integer_ + +expect_equal(lgl_row_sums(x), rowSums(x), info = "logical / rowSums / keep NA / dirty input") +expect_equal(lgl_row_sums(x, TRUE), rowSums(x, TRUE), info = "logical / rowSums / rm NA / dirty input") + +expect_equal(lgl_col_sums(x), colSums(x), info = "logical / colSums / keep NA / dirty input") +expect_equal(lgl_col_sums(x, TRUE), colSums(x, TRUE), info = "logical / colSums / rm NA / dirty input") + +expect_equal(lgl_row_means(x), rowMeans(x), info = "logical / rowMeans / keep NA / dirty input") +expect_equal(lgl_row_means(x, TRUE), rowMeans(x, TRUE), info = "logical / rowMeans / rm NA / dirty input") + +expect_equal(lgl_col_means(x), colMeans(x), info = "logical / colMeans / keep NA / dirty input") +expect_equal(lgl_col_means(x, TRUE), colMeans(x, TRUE), info = "logical / colMeans / rm NA / dirty input") + + + + + ## {row,col}{Sums,Means} complex tests +# test.sugar.rowMeans_complex <- function() { + +x <- matrix(rnorm(9) + 2i, 3) + +expect_equal(cx_row_sums(x), rowSums(x), info = "complex / rowSums / keep NA / clean input") +expect_equal(cx_row_sums(x, TRUE), rowSums(x, TRUE), info = "complex / rowSums / rm NA / clean input") + +expect_equal(cx_col_sums(x), colSums(x), info = "complex / colSums / keep NA / clean input") +expect_equal(cx_col_sums(x, TRUE), colSums(x, TRUE), info = "complex / colSums / rm NA / clean input") + +expect_equal(cx_row_means(x), rowMeans(x), info = "complex / rowMeans / keep NA / clean input") +expect_equal(cx_row_means(x, TRUE), rowMeans(x, TRUE), info = "complex / rowMeans / rm NA / clean input") + +expect_equal(cx_col_means(x), colMeans(x), info = "complex / colMeans / keep NA / clean input") +expect_equal(cx_col_means(x, TRUE), colMeans(x, TRUE), info = "complex / colMeans / rm NA / clean input") + + +x[sample(1:9, 4)] <- NA + +expect_equal(cx_row_sums(x), rowSums(x), info = "complex / rowSums / keep NA / mixed input") +expect_equal(cx_row_sums(x, TRUE), rowSums(x, TRUE), info = "complex / rowSums / rm NA / mixed input") + +expect_equal(cx_col_sums(x), colSums(x), info = "complex / colSums / keep NA / mixed input") +expect_equal(cx_col_sums(x, TRUE), colSums(x, TRUE), info = "complex / colSums / rm NA / mixed input") + +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_ + +expect_equal(cx_row_sums(x), rowSums(x), info = "complex / rowSums / keep NA / dirty input") +expect_equal(cx_row_sums(x, TRUE), rowSums(x, TRUE), info = "complex / rowSums / rm NA / dirty input") + +expect_equal(cx_col_sums(x), colSums(x), info = "complex / colSums / keep NA / dirty input") +expect_equal(cx_col_sums(x, TRUE), colSums(x, TRUE), info = "complex / colSums / rm NA / dirty input") + +expect_equal(cx_row_means(x), rowMeans(x), info = "complex / rowMeans / keep NA / dirty input") +expect_equal(cx_row_means(x, TRUE), rowMeans(x, TRUE), info = "complex / rowMeans / rm NA / dirty input") + +expect_equal(cx_col_means(x), colMeans(x), info = "complex / colMeans / keep NA / dirty input") +expect_equal(cx_col_means(x, TRUE), colMeans(x, TRUE), info = "complex / colMeans / rm NA / dirty input") + + + + +## 10 December 2016 +## sample.int tests +# test.sugar.sample_dot_int <- function() { + +set.seed(123); s1 <- sample_dot_int(10, 5) +set.seed(123); s2 <- sample(10, 5) + +expect_equal(s1, s2, info = "sample.int / without replacement / without probability") + +set.seed(123); s1 <- sample_dot_int(10, 5, TRUE) +set.seed(123); s2 <- sample(10, 5, TRUE) + +expect_equal(s1, s2, info = "sample.int / with replacement / without probability") + + +px <- rep(c(3, 2, 1), length.out = 10) +set.seed(123); s1 <- sample_dot_int(10, 5, FALSE, px) +set.seed(123); s2 <- sample(10, 5, FALSE, px) + +expect_equal(s1, s2, info = "sample.int / without replacement / with probability") + +set.seed(123); s1 <- sample_dot_int(10, 5, TRUE, px) +set.seed(123); s2 <- sample(10, 5, TRUE, px) + +expect_equal(s1, s2, info = "sample.int / with replacement / with probability") + + + + + ## sample_int tests +# test.sugar.sample_int <- function() { + +x <- as.integer(rpois(10, 10)) +px <- rep(c(3, 2, 1), length.out = 10) + +set.seed(123); s1 <- sample_int(x, 6) +set.seed(123); s2 <- sample(x, 6) + +expect_equal(s1, s2, info = "sample_int / without replacement / without probability") + +set.seed(123); s1 <- sample_int(x, 6, TRUE) +set.seed(123); s2 <- sample(x, 6, TRUE) + +expect_equal(s1, s2, info = "sample_int / with replacement / without probability") + +set.seed(123); s1 <- sample_int(x, 6, FALSE, px) +set.seed(123); s2 <- sample(x, 6, FALSE, px) + +expect_equal(s1, s2, info = "sample_int / without replacement / with probability") + +set.seed(123); s1 <- sample_int(x, 6, TRUE, px) +set.seed(123); s2 <- sample(x, 6, TRUE, px) + +expect_equal(s1, s2, info = "sample_int / with replacement / with probability") + + + + + ## sample_dbl tests +# test.sugar.sample_dbl <- function() { + +x <- rnorm(10) +px <- rep(c(3, 2, 1), length.out = 10) + +set.seed(123); s1 <- sample_dbl(x, 6) +set.seed(123); s2 <- sample(x, 6) + +expect_equal(s1, s2, info = "sample_dbl / without replacement / without probability") + +set.seed(123); s1 <- sample_dbl(x, 6, TRUE) +set.seed(123); s2 <- sample(x, 6, TRUE) + +expect_equal(s1, s2, info = "sample_dbl / with replacement / without probability") + +set.seed(123); s1 <- sample_dbl(x, 6, FALSE, px) +set.seed(123); s2 <- sample(x, 6, FALSE, px) + +expect_equal(s1, s2, info = "sample_dbl / without replacement / with probability") + +set.seed(123); s1 <- sample_dbl(x, 6, TRUE, px) +set.seed(123); s2 <- sample(x, 6, TRUE, px) + +expect_equal(s1, s2, info = "sample_dbl / with replacement / with probability") + + + + +## sample_chr tests +# test.sugar.sample_chr <- function() { + +x <- sample(letters, 10) +px <- rep(c(3, 2, 1), length.out = 10) + +set.seed(123); s1 <- sample_chr(x, 6) +set.seed(123); s2 <- sample(x, 6) + +expect_equal(s1, s2, info = "sample_chr / without replacement / without probability") + +set.seed(123); s1 <- sample_chr(x, 6, TRUE) +set.seed(123); s2 <- sample(x, 6, TRUE) + +expect_equal(s1, s2, info = "sample_chr / with replacement / without probability") + +set.seed(123); s1 <- sample_chr(x, 6, FALSE, px) +set.seed(123); s2 <- sample(x, 6, FALSE, px) + +expect_equal(s1, s2, info = "sample_chr / without replacement / with probability") + +set.seed(123); s1 <- sample_chr(x, 6, TRUE, px) +set.seed(123); s2 <- sample(x, 6, TRUE, px) + +expect_equal(s1, s2, info = "sample_chr / with replacement / with probability") + + + + +## sample_cx tests +# test.sugar.sample_cx <- function() { + +x <- rnorm(10) + 2i +px <- rep(c(3, 2, 1), length.out = 10) + +set.seed(123); s1 <- sample_cx(x, 6) +set.seed(123); s2 <- sample(x, 6) + +expect_equal(s1, s2, info = "sample_cx / without replacement / without probability") + +set.seed(123); s1 <- sample_cx(x, 6, TRUE) +set.seed(123); s2 <- sample(x, 6, TRUE) + +expect_equal(s1, s2, info = "sample_cx / with replacement / without probability") + +set.seed(123); s1 <- sample_cx(x, 6, FALSE, px) +set.seed(123); s2 <- sample(x, 6, FALSE, px) + +expect_equal(s1, s2, info = "sample_cx / without replacement / with probability") + +set.seed(123); s1 <- sample_cx(x, 6, TRUE, px) +set.seed(123); s2 <- sample(x, 6, TRUE, px) + +expect_equal(s1, s2, info = "sample_cx / with replacement / with probability") + + + + +## sample_lgl tests +# test.sugar.sample_lgl <- function() { + +x <- rbinom(10, 1, 0.5) > 0 +px <- rep(c(3, 2, 1), length.out = 10) + +set.seed(123); s1 <- sample_lgl(x, 6) +set.seed(123); s2 <- sample(x, 6) + +expect_equal(s1, s2, info = "sample_lgl / without replacement / without probability") + +set.seed(123); s1 <- sample_lgl(x, 6, TRUE) +set.seed(123); s2 <- sample(x, 6, TRUE) + +expect_equal(s1, s2, info = "sample_lgl / with replacement / without probability") + +set.seed(123); s1 <- sample_lgl(x, 6, FALSE, px) +set.seed(123); s2 <- sample(x, 6, FALSE, px) + +expect_equal(s1, s2, info = "sample_lgl / without replacement / with probability") + +set.seed(123); s1 <- sample_lgl(x, 6, TRUE, px) +set.seed(123); s2 <- sample(x, 6, TRUE, px) + +expect_equal(s1, s2, info = "sample_lgl / with replacement / with probability") + + + + +## sample_list tests +# test.sugar.sample_list <- function() { + +x <- list(letters, + 1:5, + rnorm(10), + state.abb, + state.area, + state.center, + matrix(1:9, 3), + mtcars, + AirPassengers, + BJsales) +px <- rep(c(3, 2, 1), length.out = 10) + +set.seed(123); s1 <- sample_list(x, 6) +set.seed(123); s2 <- sample(x, 6) + +expect_equal(s1, s2, info = "sample_list / without replacement / without probability") + +set.seed(123); s1 <- sample_list(x, 6, TRUE) +set.seed(123); s2 <- sample(x, 6, TRUE) + +expect_equal(s1, s2, info = "sample_list / with replacement / without probability") + +set.seed(123); s1 <- sample_list(x, 6, FALSE, px) +set.seed(123); s2 <- sample(x, 6, FALSE, px) + +expect_equal(s1, s2, info = "sample_list / without replacement / with probability") + +set.seed(123); s1 <- sample_list(x, 6, TRUE, px) +set.seed(123); s2 <- sample(x, 6, TRUE, px) + +expect_equal(s1, s2, info = "sample_list / with replacement / with probability") + + + +## 31 January 2017 +## upper_tri tests +# test.sugar.upper_tri <- function() { + +x <- matrix(rnorm(9), 3) + +expect_equal(UpperTri(x), upper.tri(x), info = "upper_tri / symmetric / diag = FALSE") + +expect_equal(UpperTri(x, TRUE), upper.tri(x, TRUE), info = "upper_tri / symmetric / diag = TRUE") + +x <- matrix(rnorm(12), 3) + +expect_equal(UpperTri(x), upper.tri(x), info = "upper_tri / [3 x 4] / diag = FALSE") + +expect_equal(UpperTri(x, TRUE), upper.tri(x, TRUE), info = "upper_tri / [3 x 4] / diag = TRUE") + +x <- matrix(rnorm(12), 4) + +expect_equal(UpperTri(x), upper.tri(x), info = "upper_tri / [4 x 3] / diag = FALSE") + +expect_equal(UpperTri(x, TRUE), upper.tri(x, TRUE), info = "upper_tri / [4 x 3] / diag = TRUE") + + + +## lower_tri tests +# test.sugar.lower_tri <- function() { + +x <- matrix(rnorm(9), 3) + +expect_equal(LowerTri(x), lower.tri(x), info = "lower_tri / symmetric / diag = FALSE") + +expect_equal(LowerTri(x, TRUE), lower.tri(x, TRUE), info = "lower_tri / symmetric / diag = TRUE") + +x <- matrix(rnorm(12), 3) + +expect_equal(LowerTri(x), lower.tri(x), info = "lower_tri / [3 x 4] / diag = FALSE") + +expect_equal(LowerTri(x, TRUE), lower.tri(x, TRUE), info = "lower_tri / [3 x 4] / diag = TRUE") + +x <- matrix(rnorm(12), 4) + +expect_equal(LowerTri(x), lower.tri(x), info = "lower_tri / [4 x 3] / diag = FALSE") + +expect_equal(LowerTri(x, TRUE), lower.tri(x, TRUE), info = "lower_tri / [4 x 3] / diag = TRUE") + + + + +## 22 April 2017 +## trimws -- vector +# test.sugar.vtrimws <- function() { + +x <- c(" a b c", "a b c ", " a b c ", + "\t\ta b c", "a b c\t\t", "\t\ta b c\t\t", + "\r\ra b c", "a b c\r\r", "\r\ra b c\r\r", + "\n\na b c", "a b c\n\n", "\n\na b c\n\n", + NA, "", " ", " \t\r\n ", "\n \t \r ") + +expect_equal(vtrimws(x), trimws(x), info = "vtrimws / which = 'both'") + +expect_equal(vtrimws(x, 'l'), trimws(x, 'l'), info = "vtrimws / which = 'left'") + +expect_equal(vtrimws(x, 'r'), trimws(x, 'r'), info = "vtrimws / which = 'right'") + +expect_error(vtrimws(x, "invalid"), info = "vtrimws -- bad `which` argument") + + +## trimws -- matrix +# test.sugar.mtrimws <- function() { + +x <- c(" a b c", "a b c ", " a b c ", + "\t\ta b c", "a b c\t\t", "\t\ta b c\t\t", + "\r\ra b c", "a b c\r\r", "\r\ra b c\r\r", + "\n\na b c", "a b c\n\n", "\n\na b c\n\n", + NA, "", " ", " \t\r\n ", "\n \t \r ") +x <- matrix(x, nrow = length(x), ncol = 4) + +expect_equal(mtrimws(x), trimws(x), info = "mtrimws / which = 'both'") + +expect_equal(mtrimws(x, 'l'), trimws(x, 'l'), info = "mtrimws / which = 'left'") + +expect_equal(mtrimws(x, 'r'), trimws(x, 'r'), info = "mtrimws / which = 'right'") + +expect_error(mtrimws(x, "invalid"), info = "mtrimws -- bad `which` argument") + + + +## trimws -- String +# test.sugar.strimws <- function() { + +x <- c(" a b c", "a b c ", " a b c ", + "\t\ta b c", "a b c\t\t", "\t\ta b c\t\t", + "\r\ra b c", "a b c\r\r", "\r\ra b c\r\r", + "\n\na b c", "a b c\n\n", "\n\na b c\n\n", + NA, "", " ", " \t\r\n ", "\n \t \r ") + +lhs <- vapply(x, strimws, character(1), USE.NAMES = FALSE) +rhs <- vapply(x, trimws, character(1), USE.NAMES = FALSE) + +expect_equal(lhs, rhs, info = "strimws / which = 'both'") + +lhs <- vapply(x, strimws, character(1), which = 'l', USE.NAMES = FALSE) +rhs <- vapply(x, trimws, character(1), which = 'l', USE.NAMES = FALSE) + +expect_equal(lhs, rhs, info = "strimws / which = 'left'") + +lhs <- vapply(x, strimws, character(1), which = 'r', USE.NAMES = FALSE) +rhs <- vapply(x, trimws, character(1), which = 'r', USE.NAMES = FALSE) + +expect_equal(lhs, rhs, info = "strimws / which = 'right'") + +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) +if (!isArm) expect_true(is.na(intmin(integer(0))), "min(integer(0))") +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_equal(doublemax(numeric(0)), -Inf, info = "max(numeric(0))") + +## 'normal' values +expect_equal(intmin(c(1:10)), 1L, info = "min(integer(...))") +expect_equal(doublemin(1.0*c(1:10)), 1.0, info = "min(numeric(...))") +expect_equal(intmax(c(1:10)), 10L, info = "min(integer(...))") +expect_equal(doublemax(1.0*c(1:10)), 10.0, info = "min(numeric(...))") diff --git a/inst/tinytest/test_sugar_var.R b/inst/tinytest/test_sugar_var.R new file mode 100644 index 000000000..a64bec8d7 --- /dev/null +++ b/inst/tinytest/test_sugar_var.R @@ -0,0 +1,36 @@ + +## Copyright (C) 2015 - 2019 Wush Wu +## +## 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.Sugar.var <- function() { +fNumeric <- Rcpp::cppFunction('double myVar(NumericVector x) { return(var(x)); }') +fInteger <- Rcpp::cppFunction('double myVar(IntegerVector x) { return(var(x)); }') +fComplex <- Rcpp::cppFunction('double myVar(ComplexVector x) { return(var(x)); }') +fLogical <- Rcpp::cppFunction('double myVar(LogicalVector x) { return(var(x)); }') +test_data_real <- 1:10 +expect_equal(fNumeric(test_data_real * 1.1), var(test_data_real * 1.1)) +expect_equal(fInteger(test_data_real), var(test_data_real)) +test_data_complex_1 <- complex(real = 5:1, imag = 2:6) +test_data_complex_2 <- complex(real = 1:5, imag = 6:10) +test_data_complex_1_known_var <- 5 +test_data_complex_2_known_var <- 5 +expect_equal(fComplex(test_data_complex_1), test_data_complex_1_known_var) +expect_equal(fComplex(test_data_complex_2), test_data_complex_2_known_var) +test_data_logical <- c(TRUE, FALSE, TRUE, FALSE, TRUE) +expect_equal(fLogical(test_data_logical), var(test_data_logical)) diff --git a/inst/tinytest/test_support.R b/inst/tinytest/test_support.R new file mode 100644 index 000000000..20c92587e --- /dev/null +++ b/inst/tinytest/test_support.R @@ -0,0 +1,37 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/support.cpp") + +# test.plus.REALSXP <- function(){ +expect_equal(plus_REALSXP(), list(NA_real_,NA_real_,NA_real_) , info = " REALSXP + REALSXP" ) + +# test.times.REALSXP <- function(){ +expect_equal(times_REALSXP(), list(NA_real_,NA_real_,NA_real_) , info = " REALSXP * REALSXP" ) + +# test.divides.REALSXP <- function(){ +expect_equal(divides_REALSXP(), list(NA_real_,NA_real_,NA_real_) , info = " REALSXP / REALSXP" ) + +# test.minus.REALSXP <- function(){ +expect_equal(minus_REALSXP(), list(NA_real_,NA_real_,NA_real_) , info = " REALSXP - REALSXP" ) + +# test.functions.REALSXP <- function(){ +expect_equal(functions_REALSXP(), list( rep(NA_real_, 20L), rep(NA_real_, 6L) ) , + info = "function(NA_REAL)" ) diff --git a/inst/tinytest/test_system.R b/inst/tinytest/test_system.R new file mode 100644 index 000000000..982a3856c --- /dev/null +++ b/inst/tinytest/test_system.R @@ -0,0 +1,36 @@ + +## Copyright (C) 2016 - 2025 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.Rcpp.system.file <- function() { +inc_rcpp <- Rcpp:::Rcpp.system.file("include") +inc_sys <- tools::file_path_as_absolute( base::system.file("include", package = "Rcpp")) +expect_equal(inc_rcpp, inc_sys, info = "Rcpp.system.file") + +# test.RcppLd <- function() { +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") +expect_true(Rcpp:::RcppCxxFlags() != "", info = "RcppCxxFlags()") +# -- side effect of print expect_null(Rcpp:::CxxFlags(), info = "CxxFlags()") + +expect_true(length(Rcpp:::RcppCapabilities()) >= 13, info = "RcppCapabilities()") diff --git a/inst/tinytest/test_table.R b/inst/tinytest/test_table.R new file mode 100644 index 000000000..59d943e41 --- /dev/null +++ b/inst/tinytest/test_table.R @@ -0,0 +1,39 @@ + +## Copyright (C) 2014 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/table.cpp") + +table_ <- function(x) c(base::table(x, useNA="ifany")) + +# test.table.numeric <- function() { +x <- c(1, 2, 1, 1, NA, NaN, -Inf, Inf) +expect_equal( RcppTable(x), table_(x), info = "table matches R: numeric case") + +# test.table.integer <- function() { +x <- c(-1L, 1L, NA_integer_, NA_integer_, 100L, 1L) +expect_equal( RcppTable(x), table_(x), info = "table matches R: integer case") + +# test.table.logical <- function() { +x <- c(TRUE, TRUE, FALSE, NA) +expect_equal( RcppTable(x), table_(x), info = "table matches R: logical case") + +# test.table.character <- function() { +x <- c("a", "a", "b", "a", NA, NA) +expect_equal( RcppTable(x), table_(x), info = "table matches R: character case") diff --git a/inst/tinytest/test_vector.R b/inst/tinytest/test_vector.R new file mode 100644 index 000000000..e8138e24e --- /dev/null +++ b/inst/tinytest/test_vector.R @@ -0,0 +1,704 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/Vector.cpp") + +# test.RawVector <- function(){ +funx <- raw_ +expect_equal( funx(), as.raw(0:9), info = "RawVector(int)" ) + +# test.RawVector.REALSXP <- function(){ +funx <- raw_REALSXP +expect_equal( funx(as.raw(0:9)), as.raw(2*0:9), info = "RawVector( RAWSXP) " ) + +# test.ExpressionVector <- function(){ +funx <- expression_ +ex <- parse( text = "rnorm; rnorm(10)" ) +## get rid of the srcref stuff so that we can compare +## more easily +attributes(ex) <- NULL +expect_equal( funx(), ex , info = "ExpressionVector" ) + + +# test.ExpressionVector.variadic <- function(){ +funx <- expression_variadic +ex <- parse( text = "rnorm; rnorm(10)" ) +attributes(ex) <- NULL +expect_equal( funx(), ex , info = "ExpressionVector (using variadic templates) " ) + +# test.ExpressionVector.parse <- function( ){ +funx <- expression_parse +code <- funx() +results <- eval( code ) +expect_equal( results, 1:10, info = "ExpressionVector parsing" ) + +# test.ExpressionVector.parse.error <- function(){ +funx <- expression_parseerror +expect_error( funx(), info = "parse error" ) + +# test.ExpressionVector.eval <- function(){ +funx <- expression_eval +expect_equal( funx(), 1:10, info = "ExpressionVector::eval" ) + +# test.ExpressionVector.eval.env <- function(){ +funx <- expression_evalenv +e <- new.env() +e[["x"]] <- sample(1:10) +expect_equal( funx(e), 1:10, info = "ExpressionVector::eval in specific environment" ) + + +# test.ComplexVector <- function(){ +funx <- complex_ +expect_equal( funx(), 0:9*(1+1i), info = "ComplexVector" ) + +# test.ComplexVector.CPLXSXP <- function(){ +funx <- complex_CPLXSXP +vv = (0:9)*(1+1i) ## not working - funx changes its argument +##expect_equal( funx(vv), 2*vv, info = "ComplexVector( CPLXSXP) " ) +expect_equal( funx((0:9)*(1+1i)), 2*(0:9)*(1+1i), info = "ComplexVector( CPLXSXP) " ) + +# test.ComplexVector.INTSXP <- function(){ +funx <- complex_INTSXP +vv <- 0L:9L +expect_equal( funx(vv), (2+0i)*vv, info = "ComplexVector( INTSXP) " ) + +# test.ComplexVector.REALSXP <- function(){ +funx <- complex_REALSXP +vv <- as.numeric(0:9) +expect_equal( funx(vv), (3+0i)*vv, info = "ComplexVector( REALSXP) " ) + + + + +# test.IntegerVector <- function(){ +fun <- integer_ctor +expect_equal( fun(), 0:9, info = "IntegerVector" ) + + +# test.IntegerVector.INTSXP_ <- function(){ +fun <- integer_INTSXP +expect_equal( fun(0:9), 2*0:9, info = "IntegerVector( INTSXP) " ) + + + +# test.IntegerVector.Dimension.constructor <- function(){ +fun <- integer_dimension_ctor_1 +expect_equal(fun(), integer(5) , info = "IntegerVector( Dimension(5))" ) + +fun <- integer_dimension_ctor_2 +expect_equal(fun(), matrix( 0L, ncol = 5, nrow = 5) , info = "IntegerVector( Dimension(5,5))" ) + +fun <- integer_dimension_ctor_3 +expect_equal(fun(), array( 0L, dim = c(2,3,4) ) , info = "IntegerVector( Dimension(2,3,4))" ) + +# test.IntegerVector.range.constructors <- function(){ +fun <- integer_range_ctor_1 +expect_equal( fun(), 0:3, info = "assign(int*, int*)" ) + +fun <- integer_range_ctor_2 +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" ) + +# test.IntegerVector.names.get <- function(){ +fun <- integer_names_get +expect_equal(fun( c("foo" = 1L, "bar" = 2L) ), c("foo", "bar"), info = "Vector::names get" ) + +# test.IntegerVector.names.indexing <- function(){ +fun <- integer_names_indexing +x <- c( "foo" = 1L, "bar" = 2L ) +expect_equal( fun( x ), 1L, info = "IntegerVector names based indexing" ) + + +# test.IntegerVector.push.back <- function(){ +fun <- integer_push_back +expect_equal( fun(1:4), 1:5, info = "IntegerVector push back" ) + +x <- 1:4 +names(x) <- letters[1:4] + +target <- 1:5 +names(target) <- c( letters[1:4], "") +expect_equal( fun(x), target, info = "IntegerVector push back names" ) + + +# test.IntegerVector.push.front <- function(){ +fun <- integer_push_front +expect_equal( fun(1:4), c(5L,1:4), info = "IntegerVector push front" ) + +x <- 1:4 +names(x) <- letters[1:4] + +target <- c( 5L, 1:4 ) +names(target) <- c( "", letters[1:4]) + +expect_equal( fun(x), target, info = "IntegerVector push front names" ) + + +# test.IntegerVector.insert <- function(){ +fun <- integer_insert +expect_equal( fun(1:4), c(5L,1L, 7L, 2:4), info = "IntegerVector insert" ) + +x <- 1:4 +names(x) <- letters[1:4] + +target <- c( 5L, 1L, 7L, 2:4 ) +names(target) <- c( "", "a", "", letters[2:4]) + +expect_equal( fun(x), target, info = "IntegerVector insert names" ) + + +# test.IntegerVector.erase <- function(){ +fun <- integer_erase +expect_equal( fun(1:4), c(1L, 2L, 4L), info = "IntegerVector erase" ) + +x <- 1:4 +names(x) <- letters[1:4] + +target <- c(1L, 2L, 4L) +names(target) <- c( "a", "b", "d" ) + +expect_equal( fun(x), target, info = "IntegerVector erase" ) + + +# test.IntegerVector.erase.range <- function(){ +x <- y <- 1:10 +names(y) <- letters[1:10] +res <- integer_erase_range( x, y ) +expect_equal( res[[1L]], c(1:5, 10L) , info = "IntegerVector erase range unnamed" ) + +z <- y[-(6:9)] +expect_equal( res[[2L]], z , info = "IntegerVector erase range named" ) + + +# test.IntegerVector.erase.range.2 <- function(){ +x <- y <- 1:10 +names(y) <- letters[1:10] +res <- integer_erase_range_2( x, y ) +expect_equal( res[[1L]], 1L , info = "IntegerVector erase range 2 unnamed" ) +expect_equal( res[[2L]], c("a" = 1L ) , info = "IntegerVector erase range 2 named" ) + + + +# test.IntegerVector.erase.range.2 <- function(){ +x <- y <- as.list(1:10) +names(y) <- letters[1:10] +res <- List_erase_range_2( x, y ) +expect_equal( res[[1L]], list( 1L ) , info = "List erase range 2 unnamed" ) +expect_equal( res[[2L]], list("a" = 1L ) , info = "List erase range 2 named" ) + + +# test.IntegerVector.erase2 <- function(){ +expect_equal( integer_erase2(1:4), c(1L, 3L, 4L), info = "IntegerVector erase2" ) + +x <- 1:4 +names(x) <- letters[1:4] + +target <- c(1L, 3L, 4L) +names(target) <- c( "a", "c", "d" ) + +expect_equal( integer_erase2(x), target, info = "IntegerVector erase2" ) + + +# test.IntegerVector.fill <- function(){ +fun <- integer_fill +x <- 1:10 +expect_equal( fun(x), rep(10L, 10 ), info = "IntegerVector.fill" ) + + +# test.IntegerVector.zero <- function( ){ +fun <- integer_zero +expect_equal( fun(), integer(0), info = "IntegerVector(0)" ) + + +# test.IntegerVector.create.zero <- function( ){ +fun <- integer_create_zero +expect_equal( fun(), integer(0), info = "IntegerVector::create()" ) + + +# test.IntegerVector.create <- function(){ +fun <- integer_create_ +expect_equal( fun(), list( c( 10L, 20L) , c(foo = 20L, bar = 30L) ), info = "IntegerVector::create" ) + + +# test.IntegerVector.clone <- function(){ +x <- 1:10 +fun <- integer_clone_ +y <- fun(x) +expect_equal( x, 1:10, info = "clone" ) +expect_equal( y, 10:1, info = "clone" ) + + +# test.NumericVector <- function(){ +funx <- numeric_ +expect_equal( funx(), as.numeric(0:9), info = "NumericVector(int)" ) + + +# test.NumericVector.REALSXP <- function(){ +funx <- numeric_REALSXP +expect_equal( funx(as.numeric(0:9)), 2*0:9, info = "NumericVector( REALSXP) " ) + + +# test.NumericVector.import <- function(){ +funx <- numeric_import +expect_equal( funx(), 0:9, info = "IntegerVector::import" ) + + +# test.NumericVector.import.transform <- function(){ +funx <- numeric_importtransform +expect_equal( funx(), (0:9)^2, info = "NumericVector::import_transform" ) + + + + + + +# test.List <- function(){ +fun <- list_ctor +expect_equal( fun(), as.list( 2*0:9), info = "GenericVector" ) + + +# test.List.template <- function(){ +fun <- list_template_ +expect_equal(fun(), list( "foo", 10L, 10.2, FALSE), info = "GenericVector" ) + + +# test.List.VECSXP <- function(){ +fun <- list_VECSXP_ +expect_equal( fun(list(1,2)), list(1,2), info = "GenericVector( VECSXP) " ) + + +# test.List.matrix.indexing <- function(){ +fun <- list_matrix_indexing_1 +## a matrix of integer vectors +x <- structure( lapply( 1:16, function(x) seq.int(x) ), dim = c( 4, 4) ) +expect_equal( fun(x), diag(x), info = "matrix indexing 1" ) + +fun <- list_matrix_indexing_2 +expect_equal(diag(fun(x)), rep(list("foo"), 4) , info = "matrix indexing lhs" ) + +## drop dimensions +dim(x) <- NULL +expect_error( fun(x) , info = "not a matrix" ) + + +# test.List.Dimension.constructor <- function(){ +fun <- list_Dimension_constructor_1 +expect_equal(fun(), + rep(list(NULL),5) , + info = "List( Dimension(5))" ) + +fun <- list_Dimension_constructor_2 +expect_equal(fun(), structure( rep( list(NULL), 25), dim = c(5,5) ), info = "List( Dimension(5,5))" ) + +fun <- list_Dimension_constructor_3 +expect_equal(fun(), array( rep(list(NULL)), dim = c(2,3,4) ) , info = "List( Dimension(2,3,4))" ) + + +# test.List.iterator <- function() { +fun <- list_iterator_ +data <- list( x = letters, y = LETTERS, z = 1:4 ) +expect_equal(fun( data, length ), list( x = 26L, y = 26L, z = 4L), info = "c++ version of lapply" ) + + +# test.List.name.indexing <- function(){ +fun <- list_name_indexing +d <- data.frame( x = 1:10, y = letters[1:10] ) +expect_equal( fun( d ), sum(1:10), info = "List names based indexing" ) + + +# test.List.push.back <- function(){ +fun <- list_push_back +d <- list( x = 1:10, y = letters[1:10] ) +expect_equal(fun( d ), list( x = 1:10, y = letters[1:10], 10L, foo = "bar" ), info = "List.push_back" ) + + +# test.List.push.front <- function(){ +fun <- list_push_front +d <- list( x = 1:10, y = letters[1:10] ) +expect_equal(fun(d), list( foo = "bar", 10L, x = 1:10, y = letters[1:10] ), info = "List.push_front" ) + + +# test.List.erase <- function(){ +fun <- list_erase +d <- list( x = 1:10, y = letters[1:10] ) +expect_equal(fun(d), list( y = letters[1:10] ), info = "List.erase" ) + + +# test.List.erase.range <- function(){ +fun <- list_erase_range +d <- list( x = 1:10, y = letters[1:10], z = 1:10 ) +expect_equal(fun(d), list( z = 1:10 ), info = "List.erase (range version)" ) + + +# test.List.implicit.push.back <- function(){ +fun <- list_implicit_push_back +expect_equal( fun(), list( foo = 10, bar = "foobar" ), info = "List implicit push back" ) + + +# test.List.create <- function(){ +fun <- list_create_ +expect_equal( fun(), list( list( 10L, "foo" ), list(foo = 10L, bar = TRUE ) ), info = "List::create" ) + + +# test.List.stdcomplex <- function(){ +fun <- list_stdcomplex +expect_equal(fun(), list( float = rep(0+0i, 10), double = rep(0+0i, 10) ), info = "range wrap over std::complex" ) + + + +# test.CharacterVector <- function(){ +fun <- character_ctor +expect_equal( fun(), rep("foo",10L), info = "CharacterVector" ) + + +# test.CharacterVector.STRSXP <- function(){ +fun <- character_STRSXP_ +expect_equal( fun(letters), paste(letters,collapse="" ), info = "CharacterVector( STRSXP) " ) + + + +# test.CharacterVector.plusequals <- function(){ +fun <- character_plusequals +expect_equal( fun(), c("foobar", "barfoobar"), info = "StringProxy::operator+=" ) + + +# test.CharacterVector.matrix.indexing <- function() { +fun <- character_matrix_indexing +x <- matrix( as.character(1:16), ncol = 4 ) +expect_equal( fun(x), paste(diag(x), collapse = ""), info = "matrix indexing" ) + +y <- as.vector( x ) +expect_error( fun(y) , info = "not a matrix" ) + +fun <- character_matrix_indexing_lhs +expect_equal( diag(fun(x)), rep("foo", 4) , info = "matrix indexing lhs" ) + + +# test.CharacterVector.matrix.row.iteration <- function() { +x <- matrix(letters[1:16], nrow = 4) + +fun <- character_matrix_row_iteration_incr +expect_equal( fun(x), "bfjn", info = "matrix row iteration post-incr" ) + +fun <- character_matrix_row_iteration_decr +expect_equal( fun(x), "njf", info = "matrix row iteration post-decr" ) + + +# test.CharacterVector.assign <- function(){ +fun <- character_assign1 +expect_equal( fun(), c("foo", "bar", "bling", "boom"), info = "assign(char**, char**)" ) + +fun <- character_assign2 +expect_equal( fun(), c("foo", "bar", "bling", "boom"), info = "assign(char**, char**)" ) + + + +# test.CharacterVector.range.constructors <- function(){ +fun <- character_range_ctor1 +expect_equal( fun(), c("foo", "bar", "bling", "boom"), info = "assign(char**, char**)" ) + +fun <- character_range_ctor2 +expect_equal( fun(), c("foo", "bar", "bling", "boom"), info = "assign(char**, char**)" ) + + +# test.CharacterVector.Dimension.constructor <- function(){ +fun <- character_dimension_ctor1 +expect_equal(fun(), character(5), info = "CharacterVector( Dimension(5))" ) + +fun <- character_dimension_ctor2 +expect_equal(fun(), matrix( "", ncol = 5, nrow = 5), info = "CharacterVector( Dimension(5,5))" ) + +fun <- character_dimension_ctor3 +expect_equal(fun(), array( "", dim = c(2,3,4) ) , info = "CharacterVector( Dimension(2,3,4))" ) + + +# test.CharacterVector.iterator <- function(){ +fun <- character_iterator1 +expect_equal(fun(letters), paste(letters, collapse=""), info = "CharacterVector::iterator explicit looping" ) + +fun <- character_iterator2 +expect_equal(fun(letters), paste(letters, collapse=""), info = "CharacterVector::iterator using std::accumulate" ) + + +# test.CharacterVector.iterator <- function(){ +fun <- character_const_iterator1 +expect_equal(fun(letters), paste(letters, collapse=""), info = "CharacterVector::iterator explicit looping" ) + +fun <- character_const_iterator2 +expect_equal(fun(letters), paste(letters, collapse=""), info = "CharacterVector::iterator using std::accumulate" ) + + +# test.CharacterVector.reverse <- function(){ +fun <- character_reverse +x <- c("foo", "bar", "bling") +x <- fun(x) +expect_equal( x, c("bling", "bar", "foo"), info = "reverse" ) +x <- fun(x) +expect_equal( x, c("foo", "bar", "bling"), info = "reverse" ) + + +# test.CharacterVector.names.indexing <- function(){ +fun <- character_names_indexing +x <- c( foo = "foo", bar = "bar" ) +expect_equal( fun(x), "foo", info = "CharacterVector names based indexing" ) + + +# test.CharacterVector.listOf <- function() { +fun <- character_listOf +expect_equal(fun(list(foo=c("tic","tac","toe"), + bar=c("Eenie","Meenie","Moe"))), + list(foo="tictactoe", bar="EenieMeenieMoe"), + info="CharacterVector from list") + + +# test.CharacterVector.find <- function(){ +fun <- character_find_ +expect_equal( fun( c("bar", "foo", "bob") ), 1L, info = "support for std::find in CharacterVector" ) + + +# test.CharacterVector.create <- function(){ +fun <- character_create_ +expect_equal( fun(), list( c( "foo", "bar" ), c(foo = "bar", bar = "foo" ) ), info = "CharacterVector::create" ) + + +# test.ComplexVector.binary.operators <- function(){ +fun <- complex_binary_sugar +x <- (1+1i) * 1:10 +y <- (2-3i) * 1:10 + +expect_equal(fun(x, y), + list("+" = x + y, + "-" = x - y, + "*" = x * y, + "/" = x / y), info = "complex binary operators" ) + + +# test.ComplexVector.binary.operators <- function(){ +fun <- List_extract +expect_equal( fun(list(TRUE, 4)), list(TRUE, 4L) ) +expect_equal( fun(list(FALSE, -4L)), list(FALSE,-4L) ) + + +# test.factors <- function(){ +fun <- factors +x <- as.factor( c("c3", "c2", "c1") ) +y <- fun(x) +expect_equal( y, as.character(x) ) + + +# test.IntegerVector_int_init <- function(){ +fun <- IntegerVector_int_init +expect_equal( fun(), c(4L,4L), info = "IntegerVector int init regression test" ) + + +# test.containsElementNamed <- function() { +fun <- containsElementNamed + +x <- list( foo = 2, bla = 1:10 ) + +expect_equal(fun(x, "foo"), TRUE, info = "containsElementNamed with element") +expect_equal(fun(x, "bar"), FALSE, info = "containsElementNamed without element") +expect_equal(fun(x, ""), FALSE, info = "containsElementNamed with empty element") + + +# test.CharacterVector.equality.operator <- function(){ +res <- CharacterVectorEqualityOperator( letters, letters ) +expect_equal( res, list( rep( TRUE, 26L ), rep( FALSE, 26L) ), info = 'CharacterVector element equality operator' ) + + +# test.List.rep.ctor <- function(){ +x <- 1:10 +res <- List_rep_ctor(x) +expected <- rep( list(x), 3 ) +expect_equal( res, expected, info = "List rep constructor" ) + + +# test.std.vector.double <- function() { +fun <- stdVectorDouble +x <- seq(1.0, 5.0, by=1.0) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorDouble") + + +# test.std.vector.double.const <- function() { +fun <- stdVectorDoubleConst +x <- seq(1.0, 5.0, by=1.0) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorDoubleConst") + + +# test.std.vector.double.ref <- function() { +fun <- stdVectorDoubleRef +x <- seq(1.0, 5.0, by=1.0) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorDoubleRef") + + +# test.std.vector.double.const.ref <- function() { +fun <- stdVectorDoubleConstRef +x <- seq(1.0, 5.0, by=1.0) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorDoubleConstRef") + + +# test.std.vector.int <- function() { +fun <- stdVectorInt +x <- seq(1L, 5L, by=1L) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorInt") + + +# test.std.vector.int.const <- function() { +fun <- stdVectorIntConst +x <- seq(1L, 5L, by=1L) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorIntConst") + + +# test.std.vector.int.ref <- function() { +fun <- stdVectorIntRef +x <- seq(1L, 5L, by=1L) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorIntRef") + + +# test.std.vector.int.const.ref <- function() { +fun <- stdVectorIntConstRef +x <- seq(1L, 5L, by=1L) +expect_equal(fun(x), 5, info = "automatic conversion of stdVectorIntConstRef") + + +# test.character.vector.const.proxy <- function(){ +res <- character_vector_const_proxy( "fooo" ) +expect_equal( res, "fooo", info = "CharacterVector const proxy. #32" ) + + +# test.CharacterVector.test.const.proxy <- function(){ +res <- CharacterVector_test_const_proxy( letters ) +expect_equal( res, letters ) + + +# test.sort <- function() { +num <- setNames( c(1, -1, 4, NA, 5, NaN), letters[1:5] ) +expect_identical( sort_numeric(num), sort(num, na.last=TRUE) ) +int <- as.integer(num) +expect_identical( sort_integer(int), sort(int, na.last=TRUE) ) +char <- setNames( sample(letters, 5), LETTERS[1:5] ) +expect_identical( sort_character(char), sort(char, na.last=TRUE) ) +lgcl <- as.logical(int) +expect_identical( sort_logical(lgcl), sort(lgcl, na.last=TRUE) ) + + +# test.sort_desc <- function() { +num <- setNames(c(1, -1, 4, NA, 5, NaN), letters[1:5]) +expect_identical(sort_numeric_desc(num), sort(num, decreasing = TRUE, na.last = FALSE)) + +int <- as.integer(num) +expect_identical(sort_integer_desc(int), sort(int, decreasing = TRUE, na.last = FALSE)) + +char <- setNames(sample(letters, 5), LETTERS[1:5]) +expect_identical(sort_character_desc(char), sort(char, decreasing = TRUE, na.last = FALSE)) + +lgcl <- as.logical(int) +expect_identical(sort_logical_desc(lgcl), sort(lgcl, decreasing = TRUE, na.last = FALSE)) + + +# test.List.assign.SEXP <- function() { +l <- list(1, 2, 3) +other <- list_sexp_assign(l) +expect_identical(l, other) + + +# test.logical.vector.from.bool <- function() { +expect_identical(logical_vector_from_bool(), TRUE) + + +# test.logical.vector.from.bool.assign <- function() { +expect_identical(logical_vector_from_bool_assign(), TRUE) + + +# test.noprotect_vector <- function(){ +x <- rnorm(10) +expect_identical( noprotect_vector(x), 10L ) + + +# test.noprotect_matrix <- function(){ +x <- matrix(rnorm(10), nrow=2) +expect_identical( noprotect_matrix(x), 2L ) + + +# test.IntegerVector.accessor.with.bounds.checking <- function() { +x <- seq(1L, 5L, by=1L) +expect_equal(vec_access_with_bounds_checking(x, 3), 4) +expect_error(vec_access_with_bounds_checking(x, 5) , info = "index out of bounds not detected" ) +expect_error(vec_access_with_bounds_checking(x, -1) , info = "index out of bounds not detected" ) + + +# test.NumericVector.print <- function() { +v <- c(1.1, 2.2, 3.3, 4.4) +s <- vec_print_numeric(v) +expect_equal(s, "1.1 2.2 3.3 4.4") + + +# test.IntegerVector.print <- function() { +v <- c(1, 2, 3, 4) +s <-vec_print_integer(v) +expect_equal(s, "1 2 3 4") + + +# test.CharacterVector.print <- function() { +v <- c("a", "b", "c", "d") +s <- vec_print_character(v) +expect_equal(s, '"a" "b" "c" "d"') + + +# test.IntegerVector.subset.under.gc <- function() { +x <- 1:1E6 +y <- 1:1E6 +gctorture(TRUE) +z <- vec_subset(x, y) +gctorture(FALSE) +expect_equal(x[y], z) + + +# test.CharacterVectorNoProtect <- function(){ +s <- "foo" +expect_equal(CharacterVectorNoProtect(s), 1L) +expect_equal(s, "") + + +# test.CharacterVectorNoProtect_crosspolicy <- function(){ +s <- "foo" +expect_equal(CharacterVectorNoProtect_crosspolicy(s), s) + + +# test.ListNoProtect_crosspolicy <- function(){ +data <- list(1:10) +data2 <- ListNoProtect_crosspolicy(data) +expect_equal(data, data2) + + +# test.CharacterVector_test_equality <- function(){ +expect_true( !CharacterVector_test_equality("foo", "bar") ) +expect_true( !CharacterVector_test_equality_crosspolicy("foo", "bar") ) + +# https://github.com/RcppCore/Rcpp/issues/1308 +# tests disabled since these could trigger UBSAN warnings / crashes +#expect_warning(NumericVector_test_out_of_bounds_read(numeric(0), 0)) +#expect_warning(NumericVector_test_out_of_bounds_read(numeric(1), 1)) +#expect_warning(CharacterVector_test_out_of_bounds_read(character(0), 0)) +#expect_warning(CharacterVector_test_out_of_bounds_read(character(1), 1)) + diff --git a/inst/tinytest/test_vector_old.R b/inst/tinytest/test_vector_old.R new file mode 100644 index 000000000..3939b5a06 --- /dev/null +++ b/inst/tinytest/test_vector_old.R @@ -0,0 +1,29 @@ + +## Copyright (C) 2014 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/VectorOld.cpp") + +# test.IntegerVector.comma <- function(){ +fun <- integer_comma +expect_equal( fun(), 0:3, info = "IntegerVector comma initialization" ) + +# test.CharacterVector.comma <- function(){ +fun <- character_comma +expect_equal( fun(), c("foo","bar", "bling" ), info = "CharacterVector comma operator" ) diff --git a/inst/tinytest/test_wrap.R b/inst/tinytest/test_wrap.R new file mode 100644 index 000000000..d0c0498c2 --- /dev/null +++ b/inst/tinytest/test_wrap.R @@ -0,0 +1,137 @@ + +## Copyright (C) 2010 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/wrap.cpp") + +# test.wrap.map.string.int <- function(){ +expect_equal(map_string_int(), c( a = 200L, b = 100L, c = 300L), info = "wrap( map) " ) + +# test.wrap.map.string.double <- function(){ +expect_equal(map_string_double(), c( a = 200, b = 100, c = 300), info = "wrap( map) " ) + +# test.wrap.map.string.bool <- function(){ +expect_equal(map_string_bool(), c( a = FALSE, b = TRUE, c = TRUE ), info = "wrap( map) " ) + +# test.wrap.map.string.Rbyte <- function(){ +expect_equal(map_string_Rbyte(), c( a = as.raw(1), b = as.raw(0), c = as.raw(2) ), + info = "wrap( map) " ) + +# test.wrap.map.string.string <- function(){ +expect_equal(map_string_string(), c( a = "bar", b = "foo", c = "bling" ), info = "wrap( map) " ) + +# test.wrap.map.string.generic <- function(){ +expect_equal(map_string_generic(), list( a = c(1L, 2L, 2L), b = c(1L, 2L), c = c(1L,2L,2L,2L) ) , + info = "wrap( map>) " ) + +# test.wrap.multimap.string.int <- function(){ +expect_equal(multimap_string_int(), c( a = 200L, b = 100L, c = 300L), + info = "wrap( multimap) ") + +# test.wrap.multimap.string.double <- function(){ +expect_equal(multimap_string_double(), c( a = 200, b = 100, c = 300), + info = "wrap( multimap) " ) + +# test.wrap.multimap.string.bool <- function(){ +expect_equal(multimap_string_bool(), c( a = FALSE, b = TRUE, c = TRUE ), + info = "wrap( multimap)") + +# test.wrap.multimap.string.Rbyte <- function(){ +expect_equal(multimap_string_Rbyte(), c( a = as.raw(1), b = as.raw(0), c = as.raw(2) ), + info = "wrap( multimap) " ) + +# test.wrap.multimap.string.string <- function(){ +expect_equal(multimap_string_string(), c( a = "bar", b = "foo", c = "bling" ), + info = "wrap( multimap) " ) + +# test.wrap.multimap.string.generic <- function(){ +expect_equal(multimap_string_generic(), list( a = c(1L, 2L, 2L), b = c(1L, 2L), c = c(1L,2L,2L,2L) ) , + info = "wrap( multimap>) " ) + +# test.nonnull.const.char <- function() { +expect_equal(nonnull_const_char(), "foo", info = "null const char*") + +# test.wrap.unordered.map.string.int <- function(){ +res <- unordered_map_string_int() +expect_equal( res[["a"]], 200L, info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["b"]], 100L, info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["c"]], 300L, info = "wrap( tr1::unordered_map) " ) + +# test.wrap.unordered.map.rcpp.string.int <- function(){ +res <- unordered_map_rcpp_string_int(c("a", "b", "c")) +expect_equal( res[["a"]], 200L, info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["b"]], 100L, info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["c"]], 300L, info = "wrap( tr1::unordered_map) " ) + +# test.unordered.set.rcpp.string <- function(){ +expect_equal(unordered_set_rcpp_string(c("a", "b", "c", "b")), + c(FALSE, FALSE, FALSE, TRUE), info = "wrap( tr1::unordered_set) " ) + +# test.wrap.unordered.map.string.double <- function(){ +res <- unordered_map_string_double() +expect_equal( res[["a"]], 200, info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["b"]], 100, info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["c"]], 300, info = "wrap( tr1::unordered_map) " ) + +# test.wrap.unordered.map.string.bool <- function(){ +res <- unordered_map_string_bool() +expect_equal( res[["a"]], FALSE, info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["b"]], TRUE , info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["c"]], TRUE , info = "wrap( tr1::unordered_map) " ) + +# test.wrap.unordered.map.string.Rbyte <- function(){ +res <- unordered_map_string_Rbyte() +expect_equal( res[["a"]], as.raw(1), info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["b"]], as.raw(0), info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["c"]], as.raw(2), info = "wrap( tr1::unordered_map) " ) + +# test.wrap.unordered.map.string.string <- function(){ +res <- unordered_map_string_string() +expect_equal( res[["a"]], "bar" , info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["b"]], "foo" , info = "wrap( tr1::unordered_map) " ) +expect_equal( res[["c"]], "bling" , info = "wrap( tr1::unordered_map) " ) + +# test.wrap.unordered.map.string.generic <- function(){ +res <- unordered_map_string_generic() +expect_equal( res[["a"]], c(1L,2L,2L) , info = "wrap( tr1::unordered_map>) " ) +expect_equal( res[["b"]], c(1L,2L) , info = "wrap( tr1::unordered_map>) " ) +expect_equal( res[["c"]], c(1L,2L,2L,2L) , info = "wrap( tr1::unordered_map>) " ) + +# test.wrap.map.int.double <- function(){ +expect_equal(map_int_double(), c("-1" = 3, "0" = 2 ), info = "std::map") + +# test.wrap.map.double.double <- function(){ +expect_equal(map_double_double(), c("0" = 2, "1.2" = 3 ), info = "std::map") + +# test.wrap.map.int.vector_double <- function(){ +expect_equal(map_int_vector_double(), list("0" = c(1,2), "1" = c(2,3) ), info = "std::map >") + +# test.wrap.map.int.Foo <- function(){ +expect_equal(sapply( map_int_Foo(), function(.) .$get() ), + c("0" = 2, "1" = 3 ), info = "std::map") + +# test.wrap.vector.Foo <- function(){ +expect_equal(sapply( vector_Foo(), function(.) .$get() ), c(2, 3), + info = "std::vector< MODULE EXPOSED CLASS >") + +# 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/inst/tinytest/test_wstring.R b/inst/tinytest/test_wstring.R new file mode 100644 index 000000000..32b4ef2a6 --- /dev/null +++ b/inst/tinytest/test_wstring.R @@ -0,0 +1,39 @@ + +## Copyright (C) 2013 - 2019 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +Rcpp::sourceCpp("cpp/wstring.cpp") + +# test.CharacterVector_wstring <- function(){ +res <- CharacterVector_wstring() +expect_equal( res, c("foobar", "foobar" ) ) + +# test.wstring_return <- function(){ +expect_equal( wstring_return(), "foo" ) + +# test.wstring_param <- function(){ +expect_equal( wstring_param( "foo", "bar" ), "foobar" ) + +# test.wrap_vector_wstring <- function(){ +expect_equal( wrap_vector_wstring( ), c("foo", "bar" ) ) + +##test.as_vector_wstring <- function(){ +## ## the "€" did not survive on Windows, so trying its unicode equivalent +## expect_equal( as_vector_wstring(letters), paste0( letters, "\u20ac" ) ) +##} diff --git a/inst/tinytest/test_xptr.R b/inst/tinytest/test_xptr.R new file mode 100644 index 000000000..bb5e5ea00 --- /dev/null +++ b/inst/tinytest/test_xptr.R @@ -0,0 +1,73 @@ + +## Copyright (C) 2009 - 2020 Dirk Eddelbuettel and Romain Francois +## Copyright (C) 2021 - 2023 Dirk Eddelbuettel, Romain Francois and 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 . + +if (Sys.getenv("RunAllRcppTests") != "yes") exit_file("Set 'RunAllRcppTests' to 'yes' to run.") + +## used below +.onWindows <- .Platform$OS.type == "windows" + +Rcpp::sourceCpp("cpp/XPtr.cpp") + +# test.XPtr <- function(){ +xp <- xptr_1() +expect_equal(typeof( xp ), "externalptr", info = "checking external pointer creation" ) + +front <- xptr_2(xp) +expect_equal( front, 1L, info = "check usage of external pointer" ) + +xptr_self_tag(xp) +expect_equal(xptr_has_self_tag(xp), T, info = "check external pointer tag preserved") + +expect_true(xptr_release(xp), info = "check release of external pointer") + +expect_true(xptr_access_released(xp), info = "check access of released external pointer") + +expect_error(xptr_use_released(xp), info = "check exception on use of released external pointer") + +if (.onWindows) exit_file("Skipping remainder of file on Windows") + +# test finalizeOnExit default depending on RCPP_USE_FINALIZE_ON_EXIT +file_path <- tempfile(fileext=".cpp") +on.exit(unlink(file_path), add=TRUE) +R <- shQuote(file.path(R.home(component = "bin"), "R")) +cmd <- paste0(R, " -s -e 'Rcpp::sourceCpp(\"", file_path, "\"); test()'") + +code <- ' +#include +using namespace Rcpp; + +template +void custom_finalizer(T* obj) { + Rcout << "custom_finalizer was called" << std::endl; + delete obj; +} + +// [[Rcpp::export]] +void test() { + XPtr x(new int); +} +' + +writeLines(code, file_path) +expect_equal(system(cmd, intern=TRUE), character(0)) + +if (packageVersion("tinytest") < "1.2.0") exit_file("Skip remainder on older test platform") + +writeLines(c("#define RCPP_USE_FINALIZE_ON_EXIT", code), file_path) +expect_equal(system(cmd, intern=TRUE), "custom_finalizer was called") diff --git a/inst/unitTests/cpp/DataFrame.cpp b/inst/unitTests/cpp/DataFrame.cpp deleted file mode 100644 index 9cc6f27f3..000000000 --- a/inst/unitTests/cpp/DataFrame.cpp +++ /dev/null @@ -1,96 +0,0 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 8 -*- -// -// DataFrame.cpp: Rcpp R/C++ interface class library -- DataFrame unit tests -// -// 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 . - -#include -using namespace Rcpp ; - -// [[Rcpp::export]] -DataFrame FromSEXP( SEXP x){ - DataFrame df(x) ; - return df; -} - -// [[Rcpp::export]] -SEXP index_byName( DataFrame df, std::string s ){ - return df[s]; -} - -// [[Rcpp::export]] -SEXP index_byPosition( DataFrame df, int i ){ - return df[i]; -} -// [[Rcpp::export]] -std::string string_element( DataFrame df ){ - CharacterVector b = df[1]; - std::string s; - s = b[1]; - return s; -} - -// [[Rcpp::export]] -DataFrame createOne(){ - IntegerVector v = IntegerVector::create(1,2,3); - return DataFrame::create(Named("a")=v); -} - -// [[Rcpp::export]] -DataFrame createTwo(){ - IntegerVector v = IntegerVector::create(1,2,3); - std::vector s(3); - s[0] = "a"; - s[1] = "b"; - s[2] = "c"; - return DataFrame::create(Named("a")=v, Named("b")=s); -} - -// [[Rcpp::export]] -DataFrame SlotProxy( S4 o, std::string yy ){ - return DataFrame( o.slot( yy ) ) ; -} - -// [[Rcpp::export]] -DataFrame AttributeProxy( List o, std::string y ){ - return DataFrame( o.attr( y )) ; -} - -// [[Rcpp::export]] -DataFrame createTwoStringsAsFactors(){ - IntegerVector v = IntegerVector::create(1,2,3); - std::vector s(3); - s[0] = "a"; - s[1] = "b"; - s[2] = "c"; - return DataFrame::create( - _["a"] = v, - _["b"] = s, - _["stringsAsFactors"] = false ); -} - -// [[Rcpp::export]] -IntegerVector DataFrame_nrow( DataFrame df){ - return IntegerVector::create(df.nrow(), df.rows()) ; -} - - -// [[Rcpp::export]] -IntegerVector DataFrame_ncol( DataFrame df){ - return IntegerVector::create(df.ncol(), df.cols()); -} diff --git a/inst/unitTests/runTests.R b/inst/unitTests/runTests.R deleted file mode 100644 index 77daafe20..000000000 --- a/inst/unitTests/runTests.R +++ /dev/null @@ -1,164 +0,0 @@ -## -*- mode: R; tab-width: 4; -*- -## -## Copyright (C) 2009 - 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 . - -## Usage: -## -## r some/path/to/runTests.R # defaults -## r some/path/to/runTests.R --local # use cwd, not pkg dir -## r some/path/to/runTests.R --output=/tmp # undo what BDR imposed -## r some/path/to/runTests.R --allTests # undo what KH imposed -## - -pkg <- "Rcpp" - -if (require("RUnit", quietly = TRUE)) { - - is_local <- function(){ - if( exists( "argv", globalenv() ) && "--local" %in% argv ) return(TRUE) - if( "--local" %in% commandArgs(TRUE) ) return(TRUE) - FALSE - } - if (is_local() ) path <- getwd() - - library(package=pkg, character.only = TRUE) - if (!(exists("path"))) ## && file.exists(path))) - path <- system.file("unitTests", package = pkg) - - ## --- Testing --- - - ## Define tests - testSuite <- defineTestSuite(name=paste(pkg, "unit testing"), dirs = path) - - ## TODO: actually prioritize which ones we want - ## for now, expensive tests (eg Modules, client packages) are skipped - checkForAllTests <- function() { - if (exists( "argv", globalenv() ) && "--allTests" %in% argv) { - Sys.setenv("RunAllRcppTests"="yes") - return(TRUE) - } - if ("--allTests" %in% commandArgs(TRUE)) { - Sys.setenv("RunAllRcppTests"="yes") - return(TRUE) - } - Sys.setenv("RunAllRcppTests"="no") - return(FALSE) - } - ## if (.Platform$OS.type == "windows" && allTests() == FALSE) { - ## ## by imposing [D-Z] (instead of an implicit A-Z) we are going from - ## ## 45 tests to run down to 38 (numbers as of release 0.8.3) - ## testSuite$testFileRegexp <- "^runit\\.[D-Z].+\\.[rR]$" - ## } - - if (Sys.getenv("RunAllRcppTests") == "") { # if env.var not yet set - checkForAllTests() # see if we want to set flag - } - - if (interactive()) { - cat("Now have RUnit Test Suite 'testSuite' for package '", pkg, - "' :\n", sep='') - str(testSuite) - cat('', "Consider doing", - "\t tests <- runTestSuite(testSuite)", "\nand later", - "\t printTextProtocol(tests)", '', sep="\n") - } else { ## run from shell / Rscript / R CMD Batch / ... - - ## Run - tests <- runTestSuite(testSuite) - - output <- NULL - - process_args <- function(argv){ - if( !is.null(argv) && length(argv) > 0 ){ - rx <- "^--output=(.*)$" - g <- grep( rx, argv, value = TRUE ) - if( length(g) ){ - sub( rx, "\\1", g[1L] ) - } - } - } - - # R CMD check uses this - if( exists( "Rcpp.unit.test.output.dir", globalenv() ) ){ - output <- Rcpp.unit.test.output.dir - } else { - - ## give a chance to the user to customize where he/she wants - ## the unit tests results to be stored with the --output= command - ## line argument - if( exists( "argv", globalenv() ) ){ - ## littler - output <- process_args(argv) - } else { - ## Rscript - output <- process_args(commandArgs(TRUE)) - } - } - - if( is.null(output) ) { # if it did not work, use parent dir - output <- ".." # as BDR does not want /tmp to be used - } - - ## Print results - output.txt <- file.path( output, sprintf("%s-unitTests.txt", pkg)) - output.html <- file.path( output, sprintf("%s-unitTests.html", pkg)) - - printTextProtocol(tests, fileName=output.txt) - message( sprintf( "saving txt unit test report to '%s'", output.txt ) ) - - ## Print HTML version to a file - ## printHTMLProtocol has problems on Mac OS X - if (Sys.info()["sysname"] != "Darwin"){ - message( sprintf( "saving html unit test report to '%s'", output.html ) ) - printHTMLProtocol(tests, fileName=output.html) - } - - ## stop() if there are any failures i.e. FALSE to unit test. - ## This will cause R CMD check to return error and stop - err <- getErrors(tests) - if( (err$nFail + err$nErr) > 0) { - data <- Filter( - function(x) any( sapply(x, function(.) .[["kind"]] ) %in% c("error","failure") ) , - tests[[1]]$sourceFileResults ) - err_msg <- sapply( data, - function(x) { - raw.msg <- paste( - sapply( Filter( function(.) .[["kind"]] %in% c("error","failure"), x ), "[[", "msg" ), - collapse = " // " - ) - raw.msg <- gsub( "Error in compileCode(f, code, language = language, verbose = verbose) : \n", "", raw.msg, fixed = TRUE ) - raw.msg <- gsub( "\n", "", raw.msg, fixed = TRUE ) - raw.msg - } - ) - msg <- sprintf( "unit test problems: %d failures, %d errors\n%s", - err$nFail, err$nErr, - paste( err_msg, collapse = "\n" ) - ) - stop( msg ) - } else{ - success <- err$nTestFunc - err$nFail - err$nErr - err$nDeactivated - cat( sprintf( "%d / %d\n", success, err$nTestFunc ) ) - } - } - -} else { - cat("R package 'RUnit' cannot be loaded -- no unit tests run\n", - "for package", pkg,"\n") -} - diff --git a/inst/unitTests/runit.DataFrame.R b/inst/unitTests/runit.DataFrame.R deleted file mode 100644 index c4795e6de..000000000 --- a/inst/unitTests/runit.DataFrame.R +++ /dev/null @@ -1,90 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("DataFrame.cpp") - - test.DataFrame.FromSEXP <- function() { - DF <- data.frame(a=1:3, b=c("a","b","c")) - checkEquals( FromSEXP(DF), DF, msg = "DataFrame pass-through") - } - - test.DataFrame.index.byName <- function() { - DF <- data.frame(a=1:3, b=c("a","b","c")) - checkEquals( index_byName(DF, "a"), DF$a, msg = "DataFrame column by name 'a'") - checkEquals( index_byName(DF, "b"), DF$b, msg = "DataFrame column by name 'b'") - } - - test.DataFrame.index.byPosition <- function() { - DF <- data.frame(a=1:3, b=c("a","b","c")) - checkEquals( index_byPosition(DF, 0), DF$a, msg = "DataFrame column by position 0") - checkEquals( index_byPosition(DF, 1), DF$b, msg = "DataFrame column by position 1") - } - - test.DataFrame.string.element <- function() { - DF <- data.frame(a=1:3, b=c("a","b","c"), stringsAsFactors=FALSE) - checkEquals( string_element(DF), DF[2,"b"], msg = "DataFrame string element") - } - - test.DataFrame.CreateOne <- function() { - DF <- data.frame(a=1:3) - checkEquals( createOne(), DF, msg = "DataFrame create1") - } - - test.DataFrame.CreateTwo <- function() { - DF <- data.frame(a=1:3, b=c("a","b","c")) - checkEquals( createTwo(), DF, msg = "DataFrame create2") - } - - test.DataFrame.SlotProxy <- function(){ - setClass("track", representation(x="data.frame", y = "function")) - df <- data.frame( x = 1:10, y = 1:10 ) - tr1 <- new( "track", x = df, y = rnorm ) - checkTrue( identical( SlotProxy(tr1, "x"), df ), msg = "DataFrame( SlotProxy )" ) - checkException( SlotProxy(tr1, "y"), msg = "DataFrame( SlotProxy ) -> exception" ) - } - - test.DataFrame.AttributeProxy <- function(){ - df <- data.frame( x = 1:10, y = 1:10 ) - tr1 <- structure( NULL, x = df, y = rnorm ) - checkTrue( identical( AttributeProxy(tr1, "x"), df) , msg = "DataFrame( AttributeProxy )" ) - checkException( AttributeProxy(tr1, "y"), msg = "DataFrame( AttributeProxy ) -> exception" ) - } - - test.DataFrame.CreateTwo.stringsAsFactors <- function() { - DF <- data.frame(a=1:3, b=c("a","b","c"), stringsAsFactors = FALSE ) - checkEquals( createTwoStringsAsFactors(), DF, msg = "DataFrame create2 stringsAsFactors = false") - } - - test.DataFrame.nrow <- function(){ - df <- data.frame( x = 1:10, y = 1:10 ) - checkEquals( DataFrame_nrow( df ), rep(nrow(df), 2) ) - } - - test.DataFrame.ncol <- function(){ - df <- data.frame( x = 1:10, y = 1:10 ) - checkEquals( DataFrame_ncol( df ), rep(ncol(df), 2) ) - } - - -} diff --git a/inst/unitTests/runit.Date.R b/inst/unitTests/runit.Date.R deleted file mode 100755 index 1d6103b3c..000000000 --- a/inst/unitTests/runit.Date.R +++ /dev/null @@ -1,279 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2010 - 2017 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("dates.cpp") - - test.Date.ctor.sexp <- function() { - fun <- ctor_sexp - d <- as.Date("2005-12-31"); checkEquals(fun(d), d, msg = "Date.ctor.sexp.1") - d <- as.Date("1970-01-01"); checkEquals(fun(d), d, msg = "Date.ctor.sexp.2") - d <- as.Date("1969-12-31"); checkEquals(fun(d), d, msg = "Date.ctor.sexp.3") - d <- as.Date("1954-07-04"); checkEquals(fun(d), d, msg = "Date.ctor.sexp.4") # cf 'Miracle of Berne' ;-) - d <- as.Date("1789-07-14"); checkEquals(fun(d), d, msg = "Date.ctor.sexp.5") # cf 'Quatorze Juillet' ;-) - } - - test.Date.ctor.notFinite <- function() { - fun <- ctor_sexp - checkEquals(fun(NA), as.Date(NA, origin="1970-01-01"), msg = "Date.ctor.na") - checkEquals(fun(NaN), as.Date(NaN, origin="1970-01-01"), msg = "Date.ctor.nan") - checkEquals(fun(Inf), as.Date(Inf, origin="1970-01-01"), msg = "Date.ctor.inf") - } - - test.Date.ctor.diffs <- function() { - fun <- ctor_sexp - now <- Sys.Date() - checkEquals(as.numeric(difftime(fun(now+0.025), fun(now), units="days")), 0.025, msg = "Date.ctor.diff.0025") - checkEquals(as.numeric(difftime(fun(now+0.250), fun(now), units="days")), 0.250, msg = "Date.ctor.diff.0250") - checkEquals(as.numeric(difftime(fun(now+2.500), fun(now), units="days")), 2.500, msg = "Date.ctor.diff.2500") - } - - test.Date.ctor.mdy <- function() { - checkEquals(ctor_mdy(), as.Date("2005-12-31"), msg = "Date.ctor.mdy") - } - - test.Date.ctor.ymd <- function() { - checkEquals(ctor_ymd(), as.Date("2005-12-31"), msg = "Date.ctor.ymd") - } - - test.Date.ctor.int <- function() { - fun <- ctor_int - d <- as.Date("2005-12-31") - checkEquals(fun(as.numeric(d)), d, msg = "Date.ctor.int") - checkEquals(fun(-1), as.Date("1970-01-01")-1, msg = "Date.ctor.int") - checkException(fun("foo"), msg = "Date.ctor -> exception" ) - } - - test.Date.ctor.string <- function() { - fun <- ctor_string - dtstr <- "1991-02-03" - dtfun <- fun(dtstr) - dtstr <- as.Date(strptime(dtstr, "%Y-%m-%d")) - ddstr <- as.Date(dtstr, "%Y-%m-%d") - checkEquals(dtfun, dtstr, msg = "Date.fromString.strptime") - checkEquals(dtfun, ddstr, msg = "Date.fromString.asDate") - } - - test.Date.operators <- function() { - checkEquals(operators(), - list(diff=-1, bigger=TRUE, smaller=FALSE, equal=FALSE, ge=TRUE, le=FALSE, ne=TRUE), - msg = "Date.operators") - } - - test.Date.components <- function() { - checkEquals(components(), - list(day=31, month=12, year=2005, weekday=7, yearday=365), - msg = "Date.components") - } - - test.vector.Date <- function(){ - checkEquals(vector_Date(), rep(as.Date("2005-12-31"),2), msg = "Date.vector.wrap") - } - - test.DateVector.wrap <- function(){ - checkEquals(Datevector_wrap(), rep(as.Date("2005-12-31"),2), msg = "DateVector.wrap") - } - - test.DateVector.operator.SEXP <- function(){ - checkEquals(Datevector_sexp(), rep(as.Date("2005-12-31"),2), msg = "DateVector.SEXP") - } - - test.Date.getFunctions <- function(){ - fun <- Date_get_functions - checkEquals(fun(as.Date("2010-12-04")), - list(year=2010, month=12, day=4, wday=7, yday=338), msg = "Date.get.functions.1") - checkEquals(fun(as.Date("2010-01-01")), - list(year=2010, month=1, day=1, wday=6, yday=1), msg = "Date.get.functions.2") - checkEquals(fun(as.Date("2009-12-31")), - list(year=2009, month=12, day=31, wday=5, yday=365), msg = "Date.get.functions.3") - } - - test.Datetime.get.functions <- function() { - fun <- Datetime_get_functions - checkEquals(fun(as.numeric(as.POSIXct("2001-02-03 01:02:03.123456", tz="UTC"))), - list(year=2001, month=2, day=3, wday=7, hour=1, minute=2, second=3, microsec=123456), - msg = "Datetime.get.functions") - } - - test.Datetime.operators <- function() { - checkEquals(Datetime_operators(), - list(diff=-60*60, bigger=TRUE, smaller=FALSE, equal=FALSE, ge=TRUE, le=FALSE, ne=TRUE), - msg = "Datetime.operators") - } - - test.Datetime.wrap <- function() { - checkEquals(as.numeric(Datetime_wrap()), as.numeric(as.POSIXct("2001-02-03 01:02:03.123456", tz="UTC")), - msg = "Datetime.wrap") - } - - test.Datetime.fromString <- function() { - fun <- Datetime_from_string - dtstr <- "1991-02-03 04:05:06.789" - dtfun <- fun(dtstr) - dtstr <- as.POSIXct(strptime(dtstr, "%Y-%m-%d %H:%M:%OS")) - checkEquals(as.numeric(dtfun), as.numeric(dtstr), msg = "Datetime.fromString") - } - - ## TZ difference ... - ##test.Datetime.ctor <- function() { - ## fun <- .Rcpp.Date$Datetime_ctor_sexp - ## checkEquals(fun(1234567), as.POSIXct(1234567, origin="1970-01-01"), msg = "Datetime.ctor.1") - ## checkEquals(fun(-120.25), as.POSIXct(-120.5, origin="1970-01-01"), msg = "Datetime.ctor.2") - ## checkEquals(fun( 120.25), as.POSIXct( 120.25, origin="1970-01-01"), msg = "Datetime.ctor.3") - ##} - - test.Datetime.ctor.notFinite <- function() { - fun <- Datetime_ctor_sexp - posixtNA <- as.POSIXct(NA, origin="1970-01-01") - checkEquals(fun(NA), posixtNA, msg = "Datetime.ctor.na") - checkEquals(fun(NaN), posixtNA, msg = "Datetime.ctor.nan") - checkEquals(fun(Inf), posixtNA, msg = "Datetime.ctor.inf") - } - - test.Datetime.ctor.diffs <- function() { - fun <- Datetime_ctor_sexp - now <- Sys.time() - ## first one is Ripley's fault as he decreed that difftime of POSIXct should stop at milliseconds - checkEquals(round(as.numeric(difftime(fun(now+0.025), fun(now), units="sec")), digits=4), 0.025, msg = "Datetime.ctor.diff.0025") - checkEquals(as.numeric(difftime(fun(now+0.250), fun(now), units="sec")), 0.250, msg = "Datetime.ctor.diff.0250") - checkEquals(as.numeric(difftime(fun(now+2.500), fun(now), units="sec")), 2.500, msg = "Datetime.ctor.diff.2500") - } - - test.DatetimeVector.ctor <- function() { - fun <- DatetimeVector_ctor - now <- Sys.time() - checkEquals(fun(now + (0:4)*60), now+(0:4)*60, msg = "Datetime.ctor.sequence") - if (Rcpp:::capabilities()[["new date(time) vectors"]]) { - vec <- c(now, NA, NaN, now+2.345) - posixtNA <- as.POSIXct(NA, origin="1970-01-01") - checkEquals(fun(vec), c(now, rep(posixtNA, 2), now+2.345), msg = "Datetime.ctor.NA.NaN.set") - vec <- c(now, -Inf, Inf, now+2.345) - checkEquals(sum(is.finite(fun(vec))), 2, msg = "Datetime.ctor.Inf.finite.set") - checkEquals(sum(is.infinite(fun(vec))), 2, msg = "Datetime.ctor.Inf.notfinite.set") - vec <- c(now, NA, NaN, Inf, now+2.345) - posixtNA <- as.POSIXct(NA, origin="1970-01-01") - posixtInf <- as.POSIXct(Inf, origin="1970-01-01") - checkEquals(fun(vec), c(now, rep(posixtNA, 2), posixtInf, now+2.345), - msg = "Datetime.ctor.NA.NaN.Inf.set") - } else { - vec <- c(now, NA, NaN, Inf, now+2.345) - posixtNA <- as.POSIXct(NA, origin="1970-01-01") - checkEquals(fun(vec), c(now, rep(posixtNA, 3), now+2.345), msg = "Datetime.ctor.NA.NaN.Inf.set") - } - } - - test.DatetimeVector.assignment <- function() { - now <- Sys.time() - v1 <- c(now, now + 1, now + 2) - v2 <- c(now + 3, now + 4, now + 5) - checkEquals(v2, DatetimeVector_assignment(v1, v2)) - } - - test.DateVector.assignment <- function() { - now <- Sys.Date() - v1 <- c(now, now + 1, now + 2) - v2 <- c(now + 3, now + 4, now + 5) - checkEquals(v2, DateVector_assignment(v1, v2)) - } - - - ## formatting - test.Date.formating <- function() { - oldTZ <- Sys.getenv("TZ") - Sys.setenv(TZ="America/Chicago") - d <- as.Date("2011-12-13") - - checkEquals(Date_format(d, "%Y-%m-%d"), - format(d), - msg="Date.formating.default") - checkEquals(Date_format(d, "%Y/%m/%d"), - format(d, "%Y/%m/%d"), - msg="Date.formating.given.format") - checkEquals(Date_ostream(d), - format(d), - msg="Date.formating.ostream") - - Sys.setenv(TZ=oldTZ) - } - - test.Datetime.formating <- function() { - olddigits <- getOption("digits.secs") - options("digits.secs"=6) - - d <- as.POSIXct("2016-12-13 14:15:16.123456") - checkEquals(Datetime_format(d,"%Y-%m-%d %H:%M:%S"), - format(d, "%Y-%m-%d %H:%M:%OS"), - msg="Datetime.formating.default") - checkEquals(Datetime_format(d, "%Y/%m/%d %H:%M:%S"), - format(d, "%Y/%m/%d %H:%M:%OS"), - msg="Datetime.formating.given.format") - checkEquals(Datetime_ostream(d), - format(d, "%Y-%m-%d %H:%M:%OS"), - msg="Datetime.formating.ostream") - - options("digits.secs"=olddigits) - } - - - test.mktime_gmtime <- function() { - d <- as.Date("2015-12-31") - checkEquals(d, gmtime_mktime(d), msg="Date.mktime_gmtime.2015") - - d <- as.Date("1965-12-31") - checkEquals(d, gmtime_mktime(d), msg="Date.mktime_gmtime.1965") - } - - test.mktime <- function() { - d <- as.Date("2015-12-31") - checkEquals(test_mktime(d), as.numeric(as.POSIXct(d)), msg="Date.test_mktime.2015") - - d <- as.Date("1970-01-01") - checkEquals(test_mktime(d), as.numeric(as.POSIXct(d)), msg="Date.test_mktime.1970") - - d <- as.Date("1954-07-04") - checkEquals(test_mktime(d), as.numeric(as.POSIXct(d)), msg="Date.test_mktime.1954") - } - - test.gmtime <- function() { - oldTZ <- Sys.getenv("TZ") - Sys.setenv(TZ="UTC") - checkEquals(test_gmtime(1441065600), as.Date("2015-09-01"), msg="Date.test_gmtime.2015") - - checkEquals(test_gmtime(0), as.Date("1970-01-01"), msg="Date.test_gmtime.1970") - - checkEquals(test_gmtime(-489024000), as.Date("1954-07-04"), msg="Date.test_gmtime.1954") - Sys.setenv(TZ=oldTZ) - } - - test.NA <- function() { - dv <- Sys.Date() + 0:2 - checkTrue(has_na_dv(dv) == FALSE, msg="DateVector.NAtest.withoutNA") - dv[1] <- NA - checkTrue(has_na_dv(dv) == TRUE, msg="DateVector.NAtest.withNA") - - dvt <- Sys.time() + 0:2 - checkTrue(has_na_dtv(dvt) == FALSE, msg="DatetimeVector.NAtest.withoutNA") - dvt[1] <- NA - checkTrue(has_na_dtv(dvt) == TRUE, msg="DatetimeVector.NAtest.withNA") - } -} diff --git a/inst/unitTests/runit.Exceptions_nocall.R b/inst/unitTests/runit.Exceptions_nocall.R deleted file mode 100644 index 64422ad30..000000000 --- a/inst/unitTests/runit.Exceptions_nocall.R +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/r -t -# -# Copyright (C) 2018 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("Exceptions_nocall.cpp") - - test.Rcpp_exception <- function() { - tryCatch(Rcpp_exception(), error = function(e){ - checkTrue(is.null(e$call)) - checkTrue(is.null(e$cppstack)) - }) - } - - test.eval_error <- function() { - tryCatch(eval_error_no_call(), error = function(e){ - checkTrue(is.null(e$call)) - checkTrue(is.null(e$cppstack)) - }) - } - -} diff --git a/inst/unitTests/runit.Function.R b/inst/unitTests/runit.Function.R deleted file mode 100644 index fd54d155d..000000000 --- a/inst/unitTests/runit.Function.R +++ /dev/null @@ -1,96 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("Function.cpp", "stats") - - test.Function <- function(){ - checkEquals( function_( rnorm ), rnorm, msg = "Function( CLOSXP )" ) - checkEquals( function_( is.function ), is.function, msg = "Pairlist( BUILTINSXP )" ) - - checkException( function_(1:10), msg = "Function( INTSXP) " ) - checkException( function_(TRUE), msg = "Function( LGLSXP )" ) - checkException( function_(1.3), msg = "Function( REALSXP) " ) - checkException( function_(as.raw(1) ), msg = "Function( RAWSXP)" ) - checkException( function_(new.env()), msg = "Function not compatible with environment" ) - } - - test.Function.variadic <- function(){ - checkEquals( function_variadic( sort, sample(1:20) ), 20:1, msg = "calling function" ) - checkException( function_variadic(sort, sort), msg = "Function, R error -> exception" ) - } - - test.Function.env <- function(){ - checkEquals( function_env(rnorm), asNamespace("stats" ), msg = "Function::environment" ) - checkException( function_env(is.function), - msg = "Function::environment( builtin) : exception" ) - checkException( function_env(`~`), - msg = "Function::environment( special) : exception" ) - } - - test.Function.unary.call <- function(){ - checkEquals( - function_unarycall( lapply( 1:10, function(n) seq(from=n, to = 0 ) ) ), - 2:11 , - msg = "unary_call(Function)" ) - } - - test.Function.binary.call <- function(){ - data <- lapply( 1:10, function(n) seq(from=n, to = 0 ) ) - res <- function_binarycall( data , rep(5L,10) ) - expected <- lapply( data, pmin, 5 ) - checkEquals( res, expected, - msg = "binary_call(Function)" ) - } - - test.Function.namespace.env <- function() { - exportedfunc <- function_namespace_env() - checkEquals( stats:::.asSparse, exportedfunc, msg = "namespace_env(Function)" ) - } - - test.Function.cons.env <- function() { - parent_env <- new.env() - parent_env$fun_parent <- rbinom - child_env <- new.env(parent = parent_env) - child_env$fun_child <- rnorm - - checkEquals(rnorm, function_cons_env("fun_child", child_env), msg = "env-lookup constructor") - checkEquals(rbinom, function_cons_env("fun_parent", child_env), msg = "env-lookup constructor: search function in parent environments") - checkException(function_cons_env("fun_child", parent_env), msg = "env-lookup constructor: fail when function not found") - } - - test.Function.cons.ns <- function() { - checkEquals(Rcpp::sourceCpp, function_cons_ns("sourceCpp", "Rcpp"), msg = "namespace-lookup constructor") - checkException(function_cons_ns("sourceCpp", "Rcppp"), msg = "namespace-lookup constructor: fail when ns does not exist") - checkException(function_cons_ns("sourceCppp", "Rcpp"), msg = "namespace-lookup constructor: fail when function not found") - } - - test.Function.eval <- function() { - checkException(exec(stop)) - # should not throw exception - exec(function() try(silent = TRUE, exec(stop))) - } - - # also check function is found in parent env - -} diff --git a/inst/unitTests/runit.InternalFunction.R b/inst/unitTests/runit.InternalFunction.R deleted file mode 100644 index 74b03b135..000000000 --- a/inst/unitTests/runit.InternalFunction.R +++ /dev/null @@ -1,41 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# Copyright (C) 2014 Christian Authmann -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if( .runThisTest ) { - - .tearDown <- function(){ - gc() - } - - .setUp <- Rcpp:::unitTestSetup("InternalFunction.cpp") - - test.internal_function_add <- function(){ - fun <- getAdd() - checkEquals( fun(10,32), 42 ) - } - - test.internal_function_concatenate <- function(){ - fun <- getConcatenate() - checkEquals( fun("Hello"," World"), "Hello World" ) - } - -} diff --git a/inst/unitTests/runit.InternalFunctionCPP11.R b/inst/unitTests/runit.InternalFunctionCPP11.R deleted file mode 100644 index a193f3b3d..000000000 --- a/inst/unitTests/runit.InternalFunctionCPP11.R +++ /dev/null @@ -1,41 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# Copyright (C) 2014 Christian Authmann -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if( .runThisTest && Rcpp:::capabilities()[["Full C++11 support"]] ) { - - .tearDown <- function(){ - gc() - } - - .setUp <- Rcpp:::unitTestSetup("InternalFunctionCPP11.cpp") - - test.internal_function_add <- function(){ - fun <- getAdd4() - checkEquals( fun(38), 42 ) - } - - test.internal_function_concatenate <- function(){ - fun <- getConcatenate() - checkEquals( fun("Hello"," World"), "Hello World" ) - } - -} diff --git a/inst/unitTests/runit.Language.R b/inst/unitTests/runit.Language.R deleted file mode 100644 index dfb1895d6..000000000 --- a/inst/unitTests/runit.Language.R +++ /dev/null @@ -1,172 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("language.cpp") - - test.Language <- function(){ - checkEquals( runit_language( call("rnorm") ), call("rnorm" ), msg = "Language( LANGSXP )" ) - checkException( runit_language(test.Language), msg = "Language not compatible with function" ) - checkException( runit_language(new.env()), msg = "Language not compatible with environment" ) - checkException( runit_language(1:10), msg = "Language not compatible with integer" ) - checkException( runit_language(TRUE), msg = "Language not compatible with logical" ) - checkException( runit_language(1.3), msg = "Language not compatible with numeric" ) - checkException( runit_language(as.raw(1) ), msg = "Language not compatible with raw" ) - } - - test.Language.variadic <- function(){ - checkEquals( runit_lang_variadic_1(), call("rnorm", 10L, 0.0, 2.0 ), - msg = "variadic templates" ) - - checkEquals( runit_lang_variadic_2(), call("rnorm", 10L, mean = 0.0, 2.0 ), - msg = "variadic templates (with names)" ) - } - - # same as above but without variadic templates - test.Language.push.back <- function(){ - checkEquals( runit_lang_push_back(), - call("rnorm", 10L, mean = 0.0, 2.0 ), - msg = "Language::push_back" ) - } - - test.Language.square <- function(){ - checkEquals( runit_lang_square_rv(), 10.0, msg = "Language::operator[] used as rvalue" ) - checkEquals( runit_lang_square_lv(), call("rnorm", "foobar", 20.0, 20.0) , msg = "Pairlist::operator[] used as lvalue" ) - } - - test.Language.function <- function(){ - checkEquals( runit_lang_fun(sort, sample(1:10)), 1:10, msg = "Language( Function ) " ) - } - - test.Language.inputoperator <- function(){ - checkEquals( runit_lang_inputop(), call("rnorm", 10L, sd = 10L ) , msg = "Language<<" ) - } - - test.Language.unary.call <- function(){ - checkEquals( - runit_lang_unarycall( 1:10 ), - lapply( 1:10, function(n) seq(from=n, to = 0 ) ), - msg = "c++ lapply using calls" ) - - } - - test.Language.unary.call.index <- function(){ - checkEquals( - runit_lang_unarycallindex( 1:10 ), - lapply( 1:10, function(n) seq(from=10, to = n ) ), - msg = "c++ lapply using calls" ) - } - - test.Language.binary.call <- function(){ - checkEquals( - runit_lang_binarycall( 1:10, 11:20 ), - lapply( 1:10, function(n) seq(n, n+10) ), - msg = "c++ lapply using calls" ) - } - - test.Language.fixed.call <- function(){ - set.seed(123) - res <- runit_lang_fixedcall() - set.seed(123) - exp <- lapply( 1:10, function(n) rnorm(10) ) - checkEquals( res, exp, msg = "std::generate" ) - } - - test.Language.in.env <- function(){ - e <- new.env() - e[["y"]] <- 1:10 - checkEquals( runit_lang_inenv(e), sum(1:10), msg = "Language::eval( SEXP )" ) - } - - test.Pairlist <- function(){ - checkEquals( runit_pairlist( pairlist("rnorm") ), pairlist("rnorm" ), msg = "Pairlist( LISTSXP )" ) - checkEquals( runit_pairlist( call("rnorm") ), pairlist(as.name("rnorm")), msg = "Pairlist( LANGSXP )" ) - checkEquals( runit_pairlist(1:10), as.pairlist(1:10) , msg = "Pairlist( INTSXP) " ) - checkEquals( runit_pairlist(TRUE), as.pairlist( TRUE) , msg = "Pairlist( LGLSXP )" ) - checkEquals( runit_pairlist(1.3), as.pairlist(1.3), msg = "Pairlist( REALSXP) " ) - checkEquals( runit_pairlist(as.raw(1) ), as.pairlist(as.raw(1)), msg = "Pairlist( RAWSXP)" ) - - checkException( runit_pairlist(runit_pairlist), msg = "Pairlist not compatible with function" ) - checkException( runit_pairlist(new.env()), msg = "Pairlist not compatible with environment" ) - - } - - test.Pairlist.variadic <- function(){ - checkEquals( runit_pl_variadic_1(), pairlist("rnorm", 10L, 0.0, 2.0 ), - msg = "variadic templates" ) - checkEquals( runit_pl_variadic_2(), pairlist("rnorm", 10L, mean = 0.0, 2.0 ), - msg = "variadic templates (with names)" ) - } - - test.Pairlist.push.front <- function(){ - checkEquals( runit_pl_push_front(), - pairlist( foobar = 10, "foo", 10.0, 1L), - msg = "Pairlist::push_front" ) - } - - test.Pairlist.push.back <- function(){ - checkEquals( runit_pl_push_back(), - pairlist( 1L, 10.0, "foo", foobar = 10), - msg = "Pairlist::push_back" ) - } - - test.Pairlist.insert <- function(){ - checkEquals( runit_pl_insert(), - pairlist( 30.0, 1L, bla = "bla", 10.0, 20.0, "foobar" ), - msg = "Pairlist::replace" ) - } - - test.Pairlist.replace <- function(){ - checkEquals( runit_pl_replace(), - pairlist( first = 1, 20.0 , FALSE), msg = "Pairlist::replace" ) - } - - test.Pairlist.size <- function(){ - checkEquals( runit_pl_size(), 3L, msg = "Pairlist::size()" ) - } - - test.Pairlist.remove <- function(){ - checkEquals( runit_pl_remove_1(), pairlist(10.0, 20.0), msg = "Pairlist::remove(0)" ) - checkEquals( runit_pl_remove_2(), pairlist(1L, 10.0), msg = "Pairlist::remove(0)" ) - checkEquals( runit_pl_remove_3(), pairlist(1L, 20.0), msg = "Pairlist::remove(0)" ) - } - - test.Pairlist.square <- function(){ - checkEquals( runit_pl_square_1(), 10.0, msg = "Pairlist::operator[] used as rvalue" ) - checkEquals( runit_pl_square_2(), pairlist(1L, "foobar", 1L) , msg = "Pairlist::operator[] used as lvalue" ) - } - - - test.Formula <- function(){ - checkEquals( runit_formula_(), x ~ y + z, msg = "Formula( string )" ) - } - - test.Formula.SEXP <- function(){ - checkEquals( runit_formula_SEXP( x ~ y + z), x ~ y + z, msg = "Formula( SEXP = formula )" ) - checkEquals( runit_formula_SEXP( "x ~ y + z" ), x ~ y + z, msg = "Formula( SEXP = STRSXP )" ) - checkEquals( runit_formula_SEXP( parse( text = "x ~ y + z") ), x ~ y + z, msg = "Formula( SEXP = EXPRSXP )" ) - checkEquals( runit_formula_SEXP( list( "x ~ y + z") ), x ~ y + z, msg = "Formula( SEXP = VECSXP(1 = STRSXP) )" ) - checkEquals( runit_formula_SEXP( list( x ~ y + z) ), x ~ y + z, msg = "Formula( SEXP = VECSXP(1 = formula) )" ) - } - -} diff --git a/inst/unitTests/runit.ListOf.R b/inst/unitTests/runit.ListOf.R deleted file mode 100644 index d614d7404..000000000 --- a/inst/unitTests/runit.ListOf.R +++ /dev/null @@ -1,101 +0,0 @@ -# Copyright (C) 2014 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("ListOf.cpp") - - x <- list( c(1, 5), c(2, 6), c(3, 7) ) - - test.ListOf.identity <- function() { - checkIdentical( - test_identity(setNames(x, c('a', 'b', 'c'))), - setNames(x, c('a', 'b', 'c')) - ) - } - - test.ListOf.lapply.sum <- function() { - x <- list( c(1, 5), c(2, 6), c(3, 7) ) - checkIdentical( test_lapply_sum(x), lapply(x, sum) ) - } - - test.ListOf.sapply.sum <- function() { - x <- list( c(1, 5), c(2, 6), c(3, 7) ) - checkIdentical( test_sapply_sum(x), sapply(x, sum) ) - } - - test.ListOf.assign <- function() { - x <- list( c(1, 5), c(2, 6), c(3, 7) ) - test_assign(x, 100, "apple") - checkIdentical( x[[2]], 100 ) - } - - test.ListOf.assign.names <- function() { - x <- setNames(list(1, 2, 3), c('a', 'b', 'c')) - test_assign_names(x) - checkIdentical( x[["a"]], x[["b"]] ) - } - - test.ListOf.arith <- function() { - checkIdentical(test_add(list(1, 2, 3)), 6) - checkIdentical(test_add_subtract(list(1, 2, 3)), 0) - checkIdentical(test_mult( list(1, 2, 3) ), 6) - checkIdentical(test_char( list("banana") ), list("apple")) - } - - test.ListOf.assign.names <- function() { - checkException(test_assign_names(list(alpha=1, beta=2, gamma=3))) - } - - test.ListOf.sub.calls <- function() { - checkEquals(test_sub_calls( list(1, 2, 3) ), 3) - } - - test.ListOf.nested <- function() { - checkEquals( - test_nested_listof( list(list(1)) ), - 1 - ) - } - - test.ListOf.convert.implicit <- function() { - checkEquals( - test_return_IVList(list(1, 2, 3)), - list(1L, 2L, 3L) - ) - } - - test.ListOf.convert.fail <- function() { - checkException( - test_return_IVList(list("a", "b", "c")) - ) - } - - test.ListOf.names <- function() { - l <- list(a = 1L, b = 2L, c = 3L) - checkEquals(listof_names(l), c("a", "b", "c")) - } - - test.ListOf.attr.foo <- function() { - l <- list(a = 1L) - attr(l, "foo") <- "bar" - checkEquals(listof_attr_foo(l), "bar") - } - -} diff --git a/inst/unitTests/runit.Matrix.R b/inst/unitTests/runit.Matrix.R deleted file mode 100644 index ea9d6d14b..000000000 --- a/inst/unitTests/runit.Matrix.R +++ /dev/null @@ -1,377 +0,0 @@ -#!/usr/bin/env r -# -# Copyright (C) 2010 - 2014 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("Matrix.cpp") - - test.List.column <- function(){ - x <- matrix( 1:16+.5, nc = 4 ) - res <- runit_Row_Column_sugar( x ) - target <- list( - x[1,], - x[,1], - x[2,], - x[,2], - x[2,] + x[,2] - ) - checkEquals( res, target, msg = "column and row as sugar" ) - - } - - test.NumericMatrix <- function(){ - x <- matrix( 1:16 + .5, ncol = 4 ) - checkEquals( matrix_numeric(x), sum(diag(x)), msg = "matrix indexing" ) - - y <- as.vector( x ) - checkException( matrix_numeric(y) , msg = "not a matrix" ) - - } - - test.CharacterMatrix <- function(){ - x <- matrix( letters[1:16], ncol = 4 ) - checkEquals( matrix_character(x), paste( diag(x), collapse = "" ) ) - } - - test.GenericMatrix <- function( ){ - g <- function(y){ - sapply( y, function(x) seq(from=x, to = 16) ) - } - x <- matrix( g(1:16), ncol = 4 ) - checkEquals( matrix_generic(x), g(diag(matrix(1:16,ncol=4))), msg = "GenericMatrix" ) - } - - test.IntegerMatrix.diag <- function(){ - expected <- matrix( 0L, nrow = 5, ncol = 5 ) - diag( expected ) <- 1L - checkEquals( matrix_integer_diag(), expected, msg = "IntegerMatrix::diag" ) - } - - test.CharacterMatrix.diag <- function(){ - expected <- matrix( "", nrow = 5, ncol = 5 ) - diag( expected ) <- "foo" - checkEquals( matrix_character_diag(), expected, msg = "CharacterMatrix::diag" ) - } - - test.NumericMatrix.Ctors <- function(){ - x <- matrix(0, 3, 3) - checkEquals( matrix_numeric_ctor1(), x, msg = "matrix from single int" ) - - x <- matrix(0, 3, 3) - checkEquals( matrix_numeric_ctor2(), x, msg = "matrix from two int" ) - } - - test.IntegerVector.matrix.indexing <- function(){ - x <- matrix( 1:16, ncol = 4 ) - checkEquals( integer_matrix_indexing(x), sum(diag(x)), msg = "matrix indexing" ) - - checkEquals( diag(integer_matrix_indexing_lhs(x)), 2*0:3, msg = "matrix indexing lhs" ) - - y <- as.vector( x ) - checkException( integer_matrix_indexing_lhs(y) , msg = "not a matrix" ) - } - - test.NumericMatrix.row <- function(){ - x <- matrix( 1:16 + .5, ncol = 4 ) - checkEquals( runit_NumericMatrix_row( x ), sum( x[1,] ), msg = "iterating over a row" ) - } - - test.NumericMatrix.row.const <- function(){ - x <- matrix( 1:16 + .5, ncol = 4 ) - checkEquals( runit_NumericMatrix_row_const( x ), sum( x[1,] ), msg = "iterating over a row" ) - } - - test.CharacterMatrix.row <- function(){ - m <- matrix( letters, ncol = 2 ) - checkEquals( runit_CharacterMatrix_row(m), paste( m[1,], collapse = "" ), msg = "CharacterVector::Row" ) - } - - test.CharacterMatrix.row.const <- function(){ - m <- matrix( letters, ncol = 2 ) - checkEquals( runit_CharacterMatrix_row_const(m), paste( m[1,], collapse = "" ), msg = "CharacterVector::Row" ) - } - - test.List.row <- function(){ - m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) - dim( m ) <- c( 4, 4 ) - checkEquals( runit_GenericMatrix_row( m ), 1 + 0:3*4, msg = "List::Row" ) - } - - test.List.row.const <- function(){ - m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) - dim( m ) <- c( 4, 4 ) - checkEquals( runit_GenericMatrix_row_const( m ), 1 + 0:3*4, msg = "List::Row" ) - } - - test.NumericMatrix.column <- function(){ - x <- matrix( 1:16 + .5, ncol = 4 ) - checkEquals( runit_NumericMatrix_column( x ), sum( x[,1] ) , msg = "iterating over a column" ) - } - - test.NumericMatrix.column.const <- function(){ - x <- matrix( 1:16 + .5, ncol = 4 ) - checkEquals( runit_NumericMatrix_column_const( x ), sum( x[,1] ) , msg = "iterating over a column" ) - } - - test.NumericMatrix.cumsum <- function(){ - x <- matrix( 1:8 + .5, ncol = 2 ) - checkEquals( runit_NumericMatrix_cumsum( x ), t(apply(x, 1, cumsum)) , msg = "cumsum" ) - } - - test.CharacterMatrix.column <- function(){ - m <- matrix( letters, ncol = 2 ) - checkEquals( runit_CharacterMatrix_column(m), paste( m[,1], collapse = "" ), msg = "CharacterVector::Column" ) - } - - test.CharacterMatrix.column.const <- function(){ - m <- matrix( letters, ncol = 2 ) - checkEquals( runit_CharacterMatrix_column_const(m), paste( m[,1], collapse = "" ), msg = "CharacterVector::Column" ) - } - - test.List.column <- function(){ - m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) - dim( m ) <- c( 4, 4 ) - checkEquals( runit_GenericMatrix_column( m ), 1:4, msg = "List::Column" ) - } - - test.List.column.const <- function(){ - m <- lapply( 1:16, function(i) seq(from=1, to = i ) ) - dim( m ) <- c( 4, 4 ) - checkEquals( runit_GenericMatrix_column_const( m ), 1:4, msg = "List::Column" ) - } - - test.NumericMatrix.colsum <- function( ){ - probs <- matrix(1:12,nrow=3) - checkEquals( runit_NumericMatrix_colsum( probs ), t(apply(probs,1,cumsum)) ) - } - - test.NumericMatrix.rowsum <- function( ){ - probs <- matrix(1:12,nrow=3) - checkEquals( runit_NumericMatrix_rowsum( probs ), apply(probs,2,cumsum) ) - } - - test.NumericMatrix.SubMatrix <- function( ){ - target <- rbind( c(3,4,5,5), c(3,4,5,5), 0 ) - checkEquals( runit_SubMatrix(), target, msg = "SubMatrix" ) - } - - test.NumericMatrix.opequals <- function() { - m <- matrix(1:4, nrow=2) - checkEquals(m, matrix_opequals(m)) - } - - test.NumericMatrix.rownames.colnames.proxy <- function() { - m <- matrix(as.numeric(1:4), nrow = 2) - runit_rownames_colnames_proxy(m, letters[1:2], LETTERS[1:2]) - checkEquals(rownames(m), letters[1:2]) - checkEquals(colnames(m), LETTERS[1:2]) - checkException(runit_rownames_colnames_proxy(m, letters[1:3], letters[1:3])) - checkException(runit_rownames_colnames_proxy(m, letters[1:2], NULL)) - - m <- matrix(as.numeric(1:9), nrow = 3) - runit_rownames_proxy(m) - checkEquals(rownames(m), c("A", "B", "C")) - checkEquals(colnames(m), NULL) - } - - test.NumericMatrix.no.init <- function() { - m <- runit_no_init_matrix() - checkEquals(m, matrix(c(0, 1, 2, 3), nrow = 2)) - } - - test.NumericMatrix.no.init.ctor <- function() { - m <- runit_no_init_matrix_ctor() - checkEquals(m, matrix(c(0, 1, 2, 3), nrow = 2)) - } - - test.NumericMatrix.no.init.ctor.nrow <- function() { - nrow <- runit_no_init_matrix_ctor_nrow() - checkEquals(nrow, 2L) - } - - test.NumericMatrix.const.Column <- function(){ - m <- matrix(as.numeric(1:9), nrow = 3) - res <- runit_const_Matrix_column(m) - checkEquals( m[,1], m[,2] ) - } - - test.IntegerMatrix.accessor.with.bounds.checking <- function() { - m <- matrix(seq(1L, 12, by=1L), nrow=4L, ncol=3L) - checkEquals(mat_access_with_bounds_checking(m, 0, 0), 1) - checkEquals(mat_access_with_bounds_checking(m, 1, 2), 10) - checkEquals(mat_access_with_bounds_checking(m, 3, 2), 12) - checkException(mat_access_with_bounds_checking(m, 4, 2) , msg = "index out of bounds not detected" ) - checkException(mat_access_with_bounds_checking(m, 3, 3) , msg = "index out of bounds not detected" ) - checkException(mat_access_with_bounds_checking(m, 3, -1) , msg = "index out of bounds not detected" ) - checkException(mat_access_with_bounds_checking(m, -1, 2) , msg = "index out of bounds not detected" ) - checkException(mat_access_with_bounds_checking(m, -1, -1) , msg = "index out of bounds not detected" ) - } - - test.IntegerMatrix.transpose <- function() { - M <- matrix(1:12, 3, 4) - checkEquals(transposeInteger(M), t(M), msg="integer transpose") - rownames(M) <- letters[1:nrow(M)] - checkEquals(transposeInteger(M), t(M), msg="integer transpose with rownames") - colnames(M) <- LETTERS[1:ncol(M)] - checkEquals(transposeInteger(M), t(M), msg="integer transpose with row and colnames") - } - - test.NumericMatrix.transpose <- function() { - M <- matrix(1.0 * (1:12), 3, 4) - checkEquals(transposeNumeric(M), t(M), msg="numeric transpose") - rownames(M) <- letters[1:nrow(M)] - checkEquals(transposeNumeric(M), t(M), msg="numeric transpose with rownames") - colnames(M) <- LETTERS[1:ncol(M)] - checkEquals(transposeNumeric(M), t(M), msg="numeric transpose with row and colnames") - } - - test.CharacterMatrix.transpose <- function() { - M <- matrix(as.character(1:12), 3, 4) - checkEquals(transposeCharacter(M), t(M), msg="character transpose") - rownames(M) <- letters[1:nrow(M)] - checkEquals(transposeCharacter(M), t(M), msg="character transpose with rownames") - colnames(M) <- LETTERS[1:ncol(M)] - checkEquals(transposeCharacter(M), t(M), msg="character transpose with row and colnames") - } - - test.Matrix.Scalar.op <- function() { - M <- matrix(c(1:12), 3, 4) - checkEquals(matrix_scalar_plus(M, 2), M + 2, msg="matrix + scalar") - checkEquals(matrix_scalar_plus2(M, 2), 2 + M, msg="scalar + matrix") - checkEquals(matrix_scalar_divide(M, 2), M / 2, msg="matrix / scalar") - checkEquals(matrix_scalar_divide2(M, 2), 2 / M, msg="scalar / matrix") - } - - ## 23 October 2016 - ## eye function - test.Matrix.eye <- function() { - - checkEquals( - dbl_eye(3), - diag(1.0, 3, 3), - "eye - numeric" - ) - - checkEquals( - int_eye(3), - diag(1L, 3, 3), - "eye - integer" - ) - - checkEquals( - cx_eye(3), - diag(1.0 + 0i, 3, 3), - "eye - complex" - ) - - ## diag(TRUE, 3, 3) was registering as - ## a numeric matrix on Travis for some reason - mat <- matrix(FALSE, 3, 3) - diag(mat) <- TRUE - checkEquals( - lgl_eye(3), - mat, - "eye - logical" - ) - } - - ## ones function - test.Matrix.ones <- function() { - - checkEquals( - dbl_ones(3), - matrix(1.0, 3, 3), - "ones - numeric" - ) - - checkEquals( - int_ones(3), - matrix(1L, 3, 3), - "ones - integer" - ) - - checkEquals( - cx_ones(3), - matrix(1.0 + 0i, 3, 3), - "ones - complex" - ) - - checkEquals( - lgl_ones(3), - matrix(TRUE, 3, 3), - "ones - logical" - ) - } - - ## zeros function - test.Matrix.zeros <- function() { - - checkEquals( - dbl_zeros(3), - matrix(0.0, 3, 3), - "zeros - numeric" - ) - - checkEquals( - int_zeros(3), - matrix(0L, 3, 3), - "zeros - integer" - ) - - checkEquals( - cx_zeros(3), - matrix(0.0 + 0i, 3, 3), - "zeros - complex" - ) - - checkEquals( - lgl_zeros(3), - matrix(FALSE, 3, 3), - "zeros - logical" - ) - } - - - test.Matrix.diagfill <- function() { - - checkEquals(num_diag_fill(diag(1.0, 2, 4), 0.0), - matrix(0.0, 2, 4), - msg = "diagonal fill - case: n < p") - - checkEquals(num_diag_fill(diag(1.0, 4, 2), 0.0), - matrix(0.0, 4, 2), - msg = "diagonal fill - case: n > p") - - checkEquals(num_diag_fill(diag(1.0, 3, 3), 0.0), - matrix(0.0, 3, 3), - msg = "diagonal fill - case: n = p") - - m <- matrix("", 2, 4) - diag(m) <- letters[1:2] - - checkEquals(char_diag_fill(m, ""), - matrix("", 2, 4), - msg = "diagonal fill - char") - - - } - -} diff --git a/inst/unitTests/runit.Module.R b/inst/unitTests/runit.Module.R deleted file mode 100644 index 4398ceeb4..000000000 --- a/inst/unitTests/runit.Module.R +++ /dev/null @@ -1,97 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# Copyright (C) 2010 - 2015 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if( .runThisTest && Rcpp:::capabilities()[["Rcpp modules"]] ) { - - .tearDown <- function(){ - gc() - } - - .setUp <- Rcpp:::unitTestSetup("Module.cpp") - - test.Module <- function(){ - checkEquals( bar( 2L ), 4L ) - checkEquals( foo( 2L, 10.0 ), 20.0 ) - checkEquals( hello(), "hello" ) - - w <- new( ModuleWorld ) - checkEquals( w$greet(), "hello" ) - w$set( "hello world" ) - checkEquals( w$greet(), "hello world" ) - w$set_ref( "hello world ref" ) - checkEquals( w$greet(), "hello world ref" ) - w$set_const_ref( "hello world const ref" ) - checkEquals( w$greet(), "hello world const ref" ) - w$clear( ) - checkEquals( w$greet(), "" ) - } - - test.Module.exposed.class <- function(){ - test <- new( ModuleTest, 3.0 ) - checkEquals( Test_get_x_const_ref(test), 3.0 ) - checkEquals( Test_get_x_const_pointer(test), 3.0 ) - checkEquals( Test_get_x_ref(test), 3.0 ) - checkEquals( Test_get_x_pointer(test), 3.0 ) - - checkEquals( attr_Test_get_x_const_ref(test), 3.0 ) - checkEquals( attr_Test_get_x_const_pointer(test), 3.0 ) - checkEquals( attr_Test_get_x_ref(test), 3.0 ) - checkEquals( attr_Test_get_x_pointer(test), 3.0 ) - } - - test.Module.property <- function(){ - w <- new( ModuleNum ) - checkEquals( w$x, 0.0 ) - checkEquals( w$y, 0L ) - - w$x <- 2.0 - checkEquals( w$x, 2.0 ) - - checkException( { w$y <- 3 } ) - } - - test.Module.member <- function(){ - w <- new( ModuleNumber ) - checkEquals( w$x, 0.0 ) - checkEquals( w$y, 0L ) - - w$x <- 2.0 - checkEquals( w$x, 2.0 ) - - checkException( { w$y <- 3 } ) - } - - test.Module.Constructor <- function() { - r <- new( ModuleRandomizer, 10.0, 20.0 ) - set.seed(123) - x10 <- runif(10, 10.0, 20.0) - set.seed(123) - checkEquals(r$get(10), x10) - } - - test.Module.flexible.semantics <- function( ){ - checkEquals( test_reference( seq(0,10) ), 11L ) - checkEquals( test_const_reference( seq(0,10) ), 11L ) - checkEquals( test_const( seq(0,10) ), 11L ) - } - -} diff --git a/inst/unitTests/runit.Module.client.package.R b/inst/unitTests/runit.Module.client.package.R deleted file mode 100644 index f7bead666..000000000 --- a/inst/unitTests/runit.Module.client.package.R +++ /dev/null @@ -1,70 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# Copyright (C) 2010 - 2015 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 . - -.tearDown <- function(){ - gc() -} - -## The unit test in this file fails on OS X 10.5.* but pass on 10.6.* -## Sys.info release comes back with 10.* for the latter but 9.* for the former -## Thanks to Simon Urbanek and Baptiste Auguie for suggesting and testing this -.badOSX <- (Sys.info()['sysname'] == "Darwin" && - isTRUE(as.integer(gsub("\\..*","",Sys.info()['release'])) < 10L) ) - -## It now (Dec 2011) appears to fail on Windows too -.onWindows <- .Platform$OS.type == "windows" - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest && ! .badOSX && ! .onWindows) { - - ## ## added test for 'testRcppClass' example of extending C++ classes via R - test.Class.package <- function( ){ - - td <- tempfile() - cwd <- getwd() - dir.create( td ) - file.copy( system.file( "unitTests", "testRcppClass", package = "Rcpp" ) , td, recursive = TRUE) - setwd( td ) - on.exit( { setwd( cwd) ; unlink( td, recursive = TRUE ) } ) - R <- shQuote( file.path( R.home( component = "bin" ), "R" )) - cmd <- paste( R , "CMD build testRcppClass" ) - system( cmd ) - dir.create( "templib" ) - install.packages( "testRcppClass_0.1.tar.gz", "templib", repos = NULL, type = "source" ) - - require( "testRcppClass", "templib", character.only = TRUE ) - - v <- stdNumeric$new() - data <- as.numeric(1:10) - v$assign(data) - v$set(3L, v$at(3L) + 1) - - data[[4]] <- data[[4]] +1 - - checkEquals( v$as.vector(), data ) - - ## a few function calls - checkEquals( bar(2), 4) - checkEquals( foo(2,3), 6) - - } - -} diff --git a/inst/unitTests/runit.RObject.R b/inst/unitTests/runit.RObject.R deleted file mode 100644 index feead6ca5..000000000 --- a/inst/unitTests/runit.RObject.R +++ /dev/null @@ -1,188 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2009 - 2014 Romain Francois and 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("RObject.cpp") - - test.RObject.asDouble <- function(){ - checkEquals( asDouble(2.123), 4.246, msg = "as( REALSXP ) " ) - checkEquals( asDouble(2L), 4.0, msg = "as( INTSXP ) " ) - checkEquals( asDouble(as.raw(2L)), 4.0, msg = "as( RAWSXP )" ) - checkException( asDouble('2'), msg = "as( STRSXP ) -> exception" ) - checkException( asDouble(2:3), msg = "as expects the vector to be of length 1" ) - } - - test.RObject.asInt <- function(){ - checkEquals( asInt(2.123), 4L, msg = "as( REALSXP )" ) - checkEquals( asInt(2), 4L, msg = "as( REALSXP )" ) - checkEquals( asInt(2L), 4.0, msg = "as( INTSXP )" ) - checkEquals( asInt(as.raw(2L)), 4.0, msg = "as( RAWSXP )" ) - checkException( asInt( '2'), msg = "as can not convert character" ) - checkException( asInt( 2:3), msg = "as expects the vector to be of length 1" ) - } - - test.RObject.asStdString <- function(){ - checkEquals( asStdString("abc"), "abcabc", msg = "as" ) - checkException( asStdString(NULL), msg = "as expects character vector" ) - checkException( asStdString(0L), msg = "as expects character vector" ) - checkException( asStdString(0.1), msg = "as expects character vector" ) - checkException( asStdString(as.raw(0L)), msg = "as expects character vector" ) - - checkException( asStdString(letters), msg = "as expects single string" ) - } - - test.RObject.asRaw <- function(){ - checkEquals( asRaw(1L), as.raw(2L), msg = "as(integer)" ) - checkEquals( asRaw(1.3), as.raw(2L), msg = "as(numeric)" ) - checkEquals( asRaw(as.raw(1)), as.raw(2L), msg = "as(raw)" ) - checkException( asRaw(NULL) , msg = "as(NULL) -> exception" ) - checkException( asRaw("foo") , msg = "as(character) -> exception" ) - checkException( asRaw(1:2), msg = "as(>1 integer) -> exception" ) - checkException( asRaw(as.numeric(1:2)), msg = "as(>1 numeric) -> exception" ) - checkException( asRaw(as.raw(1:3)), msg = "as(>1 raw) -> exception" ) - checkException( asRaw(integer(0)), msg = "as(0 integer) -> exception" ) - checkException( asRaw(numeric(0)), msg = "as(0 numeric) -> exception" ) - checkException( asRaw(raw(0)), msg = "as(0 raw) -> exception" ) - } - - test.RObject.asLogical <- function(){ - checkTrue( !asLogical(TRUE), msg = "as(TRUE) -> true" ) - checkTrue( asLogical(FALSE), msg = "as(FALSE) -> false" ) - checkTrue( !asLogical(1L), msg = "as(1L) -> true" ) - checkTrue( asLogical(0L), msg = "as(0L) -> false" ) - checkTrue( !asLogical(1.0), msg = "as(1.0) -> true" ) - checkTrue( asLogical(0.0), msg = "as0.0) -> false" ) - checkTrue( !asLogical(as.raw(1)), msg = "as(aw.raw(1)) -> true" ) - checkTrue( asLogical(as.raw(0)), msg = "as(as.raw(0)) -> false" ) - - checkException( asLogical(NULL), msg = "as(NULL) -> exception" ) - checkException( asLogical(c(TRUE,FALSE)), msg = "as(>1 logical) -> exception" ) - checkException( asLogical(1:2), msg = "as(>1 integer) -> exception" ) - checkException( asLogical(1:2+.1), msg = "as(>1 numeric) -> exception" ) - checkException( asLogical(as.raw(1:2)), msg = "as(>1 raw) -> exception" ) - - checkException( asLogical(integer(0)), msg = "as(0 integer) -> exception" ) - checkException( asLogical(numeric(0)), msg = "as(0 numeric) -> exception" ) - checkException( asLogical(raw(0)), msg = "as(0 raw) -> exception" ) - } - - test.RObject.asStdVectorInt <- function(){ - checkEquals( asStdVectorInt(x=2:5), 2:5*2L, msg = "as< std::vector >(integer)" ) - checkEquals( asStdVectorInt(x=2:5+.1), 2:5*2L, msg = "as< std::vector >(numeric)" ) - checkEquals( asStdVectorInt(x=as.raw(2:5)), 2:5*2L, msg = "as< std::vector >(raw)" ) - checkException( asStdVectorInt("foo"), msg = "as< std::vector >(character) -> exception" ) - checkException( asStdVectorInt(NULL), msg = "as< std::vector >(NULL) -> exception" ) - } - - test.RObject.asStdVectorDouble <- function(){ - checkEquals( asStdVectorDouble(x=0.1+2:5), 2*(0.1+2:5), msg = "as< std::vector >( numeric )" ) - checkEquals( asStdVectorDouble(x=2:5), 2*(2:5), msg = "as< std::vector >(integer)" ) - checkEquals( asStdVectorDouble(x=as.raw(2:5)), 2*(2:5), msg = "as< std::vector >(raw)" ) - checkException( asStdVectorDouble("foo"), msg = "as< std::vector >(character) -> exception" ) - checkException( asStdVectorDouble(NULL), msg = "as< std::vector >(NULL) -> exception" ) - } - - test.RObject.asStdVectorRaw <- function(){ - checkEquals( asStdVectorRaw(x=as.raw(0:9)), as.raw(2*(0:9)), msg = "as< std::vector >(raw)" ) - checkEquals( asStdVectorRaw(x=0:9), as.raw(2*(0:9)), msg = "as< std::vector >( integer )" ) - checkEquals( asStdVectorRaw(x=as.numeric(0:9)), as.raw(2*(0:9)), msg = "as< std::vector >(numeric)" ) - checkException( asStdVectorRaw("foo"), msg = "as< std::vector >(character) -> exception" ) - checkException( asStdVectorRaw(NULL), msg = "as< std::vector >(NULL) -> exception" ) - } - - test.RObject.asStdVectorBool <- function(){ - checkEquals( asStdVectorBool(x=c(TRUE,FALSE)), c(FALSE, TRUE), msg = "as< std::vector >(logical)" ) - checkEquals( asStdVectorBool(x=c(1L, 0L)), c(FALSE, TRUE), msg = "as< std::vector >(integer)" ) - checkEquals( asStdVectorBool(x=c(1.0, 0.0)), c(FALSE, TRUE), msg = "as< std::vector >(numeric)" ) - checkEquals( asStdVectorBool(x=as.raw(c(1,0))), c(FALSE, TRUE), msg = "as< std::vector >(raw)" ) - checkException( asStdVectorBool("foo"), msg = "as< std::vector >(character) -> exception" ) - checkException( asStdVectorBool(NULL), msg = "as< std::vector >(NULL) -> exception" ) - } - - test.RObject.asStdVectorString <- function(){ - checkEquals( asStdVectorString(c("foo", "bar")), c("foofoo", "barbar"), msg = "as< std::vector >(character)" ) - checkException( asStdVectorString(1L), msg = "as< std::vector >(integer) -> exception" ) - checkException( asStdVectorString(1.0), msg = "as< std::vector >(numeric) -> exception" ) - checkException( asStdVectorString(as.raw(1)), msg = "as< std::vector >(raw) -> exception" ) - checkException( asStdVectorString(TRUE), msg = "as< std::vector >(logical) -> exception" ) - checkException( asStdVectorString(NULL), msg = "as< std::vector >(NULL) -> exception" ) - } - - test.RObject.stdsetint <- function(){ - checkEquals( stdsetint(), c(0L, 1L), msg = "wrap( set )" ) - } - - test.RObject.stdsetdouble <- function(){ - checkEquals( stdsetdouble(), as.numeric(0:1), msg = "wrap( set" ) - } - - test.RObject.stdsetraw <- function(){ - checkEquals( stdsetraw(), as.raw(0:1), msg = "wrap(set)" ) - } - - test.RObject.stdsetstring <- function(){ - checkEquals( stdsetstring(), c("bar", "foo"), msg = "wrap(set)" ) - } - - test.RObject.attributeNames <- function(){ - df <- data.frame( x = 1:10, y = 1:10 ) - checkTrue( all( c("names","row.names","class") %in% attributeNames(df)), msg = "RObject.attributeNames" ) - } - - test.RObject.hasAttribute <- function(){ - df <- data.frame( x = 1:10 ) - checkTrue( hasAttribute( df ), msg = "RObject.hasAttribute" ) - } - - test.RObject.attr <- function(){ - df <- data.frame( x = 1:150 ) - rownames(df) <- 1:150 - checkEquals( attr_( iris ), 1:150, msg = "RObject.attr" ) - } - - test.RObject.attr.set <- function(){ - checkEquals( attr(attr_set(), "foo"), 10L, msg = "RObject.attr() = " ) - } - - test.RObject.isNULL <- function(){ - df <- data.frame( x = 1:10 ) - checkTrue( !isNULL( df ), msg = "RObject.isNULL(data frame) -> false" ) - checkTrue( !isNULL(1L), msg = "RObject.isNULL(integer) -> false" ) - checkTrue( !isNULL(1.0), msg = "RObject.isNULL(numeric) -> false" ) - checkTrue( !isNULL(as.raw(1)), msg = "RObject.isNULL(raw) -> false" ) - checkTrue( !isNULL(letters), msg = "RObject.isNULL(character) -> false") - checkTrue( !isNULL(test.RObject.isNULL), msg = "RObject.isNULL(function) -> false" ) - checkTrue( !isNULL(.GlobalEnv), msg = "RObject.isNULL(environment) -> false" ) - checkTrue( isNULL(NULL), msg = "RObject.isNULL(NULL) -> true" ) - } - - test.RObject.inherits <- function(){ - x <- 1:10 - checkTrue( !inherits_(x) ) - class(x) <- "foo" - checkTrue( inherits_(x) ) - class(x) <- c("foo", "bar" ) - checkTrue( inherits_(x) ) - } - -} diff --git a/inst/unitTests/runit.Rcpp.package.skeleton.R b/inst/unitTests/runit.Rcpp.package.skeleton.R deleted file mode 100644 index 44020a10b..000000000 --- a/inst/unitTests/runit.Rcpp.package.skeleton.R +++ /dev/null @@ -1,151 +0,0 @@ -# Copyright (C) 2013 - 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - test.Rcpp.package.skeleton <- function(){ - - tempdir <- tempdir() - path <- tempdir - pkg_path <- file.path(path, "foo") - R_path <- file.path(pkg_path, "R") - src_path <- file.path(pkg_path, "src") - env <- new.env() - - env$funA <- function(alpha, beta) "gamma" - env$funB <- function(first, ..., last) "foo" - - Rcpp.package.skeleton("foo", path=path, list=c("funA", "funB"), - author="Boo-Boo Bear", - maintainer="Yogi Bear", - license="An Opensource License", - email="yogibear@yogimail.com", - environment=env - ) - - on.exit(unlink(pkg_path, recursive=TRUE)) - - 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") - checkTrue( DESCRIPTION["License"] == "An Opensource License", - "wrote the License field in DESCRIPTION" ) - checkTrue( DESCRIPTION["LinkingTo"] == "Rcpp", - "we make sure that we 'link' to Rcpp (use its headers)" ) - - ## make sure we have useDynLib in the namespace - NAMESPACE <- readLines( file.path(pkg_path, "NAMESPACE") ) - - ## note: we use regular expressions anticipating a possible future - ## usage of e.g. '.registration=TRUE' in Rcpp.package.skeleton - checkTrue( any(grepl( "useDynLib(foo", NAMESPACE, fixed=TRUE )), - "NAMESPACE has useDynLib(foo)" ) - - R_files <- list.files(R_path, full.names=TRUE) - checkTrue( all( c("funA.R", "funB.R") %in% list.files(R_path)), - "created R files from functions" ) - for (file in grep("RcppExports.R", R_files, invert=TRUE, value=TRUE)) { - code <- readLines(file) - fn <- eval(parse(text=paste(code, collapse="\n"))) - fn_name <- gsub(".*/(.*)\\.R$", "\\1", file) - checkIdentical(fn, get(fn_name), - sprintf("we parsed the function '%s' correctly", fn_name) - ) - } - - ## make sure we can build the package as generated - ## note: the generated .Rd placeholders are insufficient to be able - ## to successfully install the pkg; e.g. I see - - ## Error in Rd_info(db[[i]]) : - ## missing/empty \title field in '/funA.Rd' - invisible(sapply( list.files( file.path(pkg_path, "man"), full.names=TRUE), unlink )) - - owd <- getwd() - setwd(path) - on.exit( setwd(owd), add=TRUE ) - 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") - dir.create("templib") - install.packages("foo_1.0.tar.gz", file.path(path, "templib"), repos=NULL, type="source") - on.exit( unlink( file.path(path, "foo_1.0.tar.gz") ), add=TRUE) - require("foo", file.path(path, "templib"), character.only=TRUE) - on.exit( unlink( file.path(path, "templib"), recursive=TRUE), add=TRUE ) - - } - - test.Rcpp.package.skeleton.Attributes <- function() { - - tempdir <- tempdir() - path <- tempdir - pkg_path <- file.path(path, "foo") - R_path <- file.path(pkg_path, "R") - src_path <- file.path(pkg_path, "src") - - Rcpp.package.skeleton("foo", path=path, attributes=TRUE, example_code=TRUE, - environment=environment()) - on.exit( unlink(pkg_path, recursive=TRUE) ) - checkTrue(file.exists( file.path(src_path, "RcppExports.cpp")), - "RcppExports.cpp was created") - checkTrue(file.exists( file.path(src_path, "rcpp_hello_world.cpp")), - "rcpp_hello_world.cpp was created" ) - checkTrue(file.exists( file.path(R_path, "RcppExports.R")), - "RcppExports.R was created") - } - - test.Rcpp.package.skeleton.NoAttributes <- function() { - - tempdir <- tempdir() - path <- tempdir - pkg_path <- file.path(path, "foo") - R_path <- file.path(pkg_path, "R") - src_path <- file.path(pkg_path, "src") - - Rcpp.package.skeleton("foo", path=path, attributes=FALSE, example_code=TRUE, - environment=environment()) - on.exit( unlink(pkg_path, recursive=TRUE) ) - checkTrue(file.exists( file.path(src_path, "rcpp_hello_world.cpp")), - "rcpp_hello_world.cpp was created") - checkTrue(file.exists( file.path(src_path, "rcpp_hello_world.h")), - "rcpp_hello_world.h was created") - checkTrue(file.exists( file.path(R_path, "rcpp_hello_world.R")), - "rcpp_hello_world.R was created" ) - } - - test.Rcpp.package.skeleton.Module <- function() { - - tempdir <- tempdir() - path <- tempdir - pkg_path <- file.path(path, "foo") - R_path <- file.path(pkg_path, "R") - src_path <- file.path(pkg_path, "src") - - Rcpp.package.skeleton("foo", path=path, module=TRUE, environment=environment()) - on.exit(unlink(pkg_path, recursive=TRUE)) - checkTrue(file.exists( file.path(src_path, "rcpp_module.cpp")), - "rcpp_module.cpp was created") - } - -} diff --git a/inst/unitTests/runit.Reference.R b/inst/unitTests/runit.Reference.R deleted file mode 100644 index ac96335f6..000000000 --- a/inst/unitTests/runit.Reference.R +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env r -# -# Copyright (C) 2013 - 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("Reference.cpp") - - test.Reference <- function(){ - Instrument <- setRefClass( - Class="Instrument", - fields=list("id"="character", "description"="character") - ) - Instrument$accessors(c("id", "description")) - - instrument <- Instrument$new(id="AAPL", description="Apple") - - checkEquals( runit_Reference_getId(instrument), "AAPL", msg = ".field" ) - } - -} diff --git a/inst/unitTests/runit.S4.R b/inst/unitTests/runit.S4.R deleted file mode 100644 index e594f1fa0..000000000 --- a/inst/unitTests/runit.S4.R +++ /dev/null @@ -1,103 +0,0 @@ -#!/usr/bin/env r -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("S4.cpp") - - test.RObject.S4methods <- function(){ - setClass("track", representation(x="numeric", y="numeric")) - tr <- new( "track", x = 2, y = 2 ) - checkEquals( - S4_methods(tr), - list( TRUE, TRUE, FALSE, 2.0, 2.0 ), - msg = "slot management" ) - - S4_getslots( tr ) - checkEquals( tr@x, 10.0 , msg = "slot('x') = 10" ) - checkEquals( tr@y, 20.0 , msg = "slot('y') = 20" ) - - checkException( S4_setslots( tr ), msg = "slot does not exist" ) - checkException( S4_setslots_2( tr ), msg = "slot does not exist" ) - - } - - test.S4 <- function(){ - setClass("track", - representation(x="numeric", y="numeric")) - tr <- new( "track", x = 2, y = 3 ) - checkEquals( S4_get_slot_x( tr ), 2, msg = "S4( SEXP )" ) - checkException( S4_get_slot_x( list( x = 2, y = 3 ) ), msg = "not S4" ) - checkException( S4_get_slot_x( structure( list( x = 2, y = 3 ), class = "track" ) ), msg = "S3 is not S4" ) - - tr <- S4_ctor( "track" ) - checkTrue( inherits( tr, "track" ) ) - checkEquals( tr@x, numeric(0) ) - checkEquals( tr@y, numeric(0) ) - checkException( S4_ctor( "someclassthatdoesnotexist" ) ) - } - - - test.S4.is <- function(){ - setClass("track", representation(x="numeric", y="numeric")) - setClass("trackCurve", representation(smooth = "numeric"), contains = "track") - - tr1 <- new( "track", x = 2, y = 3 ) - tr2 <- new( "trackCurve", x = 2, y = 3, smooth = 5 ) - - checkTrue( S4_is_track( tr1 ), msg = 'track is track' ) - checkTrue( S4_is_track( tr2 ), msg = 'trackCurve is track' ) - - checkTrue( !S4_is_trackCurve( tr1 ), msg = 'track is not trackCurve' ) - checkTrue( S4_is_trackCurve( tr2 ), msg = 'trackCurve is trackCurve' ) - - } - - test.Vector.SlotProxy.ambiguity <- function(){ - setClass("track", representation(x="numeric", y="numeric")) - setClass("trackCurve", representation(smooth = "numeric"), contains = "track") - - tr1 <- new( "track", x = 2, y = 3 ) - checkEquals( S4_get_slot_x(tr1), 2, "Vector( SlotProxy ) ambiguity" ) - - } - - test.Vector.AttributeProxy.ambiguity <- function(){ - x <- 1:10 - attr( x, "foo" ) <- "bar" - - checkEquals( S4_get_attr_x(x), "bar", "Vector( AttributeProxy ) ambiguity" ) - - } - - test.S4.dotdataslot <- function(){ - setClass( "Foo", contains = "character", representation( x = "numeric" ) ) - foo <- S4_dotdata( new( "Foo", "bla", x = 10 ) ) - checkEquals( as.character( foo) , "foooo" ) - } - - test.S4.proxycoerce <- function() { - setClass("Foo", list(data="integer")) - foo <- new("Foo", data=1:3) - checkEquals( S4_proxycoerce(foo), c(1, 2, 3) ) - } - -} diff --git a/inst/unitTests/runit.String.R b/inst/unitTests/runit.String.R deleted file mode 100644 index 9820c58a8..000000000 --- a/inst/unitTests/runit.String.R +++ /dev/null @@ -1,97 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2012 - 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("String.cpp") - - test.replace_all <- function(){ - checkEquals( String_replace_all("abcdbacdab", "ab", "AB"), "ABcdbacdAB") - } - test.replace_first <- function(){ - checkEquals( String_replace_first("abcdbacdab", "ab", "AB"), "ABcdbacdab") - } - test.replace_last <- function(){ - checkEquals( String_replace_last("abcdbacdab", "ab", "AB"), "abcdbacdAB") - } - - test.String.sapply <- function(){ - res <- test_sapply_string( "foobar", c("o", "a" ), c("*", "!" ) ) - checkEquals( res, "f**b!r" ) - } - - test.compare.Strings <- function(){ - res <- test_compare_Strings( "aaa", "aab" ) - target <- list( - "a < b" = TRUE, - "a > b" = FALSE, - "a == b" = FALSE, - "a == a" = TRUE - ) - checkEquals( res, target ) - } - - test.compare.String.string_proxy <- function(){ - v <- c("aab") - res <- test_compare_String_string_proxy( "aaa", v ) - target <- list( - "a == b" = FALSE, - "a != b" = TRUE, - "b == a" = FALSE, - "b != a" = TRUE - ) - checkEquals( res, target ) - } - - test.compare.String.const_string_proxy <- function(){ - v <- c("aab") - res <- test_compare_String_const_string_proxy( "aaa", v ) - target <- list( - "a == b" = FALSE, - "a != b" = TRUE, - "b == a" = FALSE, - "b != a" = TRUE - ) - checkEquals( res, target ) - } - - test.String.ctor <- function() { - res <- test_ctor("abc") - checkIdentical(res, "abc") - } - - test.push.front <- function() { - res <- test_push_front("def") - checkIdentical(res, "abcdef") - } - - test.String.encoding <- function() { - a <- b <- "å" - Encoding(a) <- "unknown" - Encoding(b) <- "UTF-8" - checkEquals(test_String_encoding(a), 0) - checkEquals(test_String_encoding(b), 1) - checkEquals(Encoding(test_String_set_encoding(a)), "UTF-8") - checkEquals(Encoding(test_String_ctor_encoding(a)), "UTF-8") - checkEquals(Encoding(test_String_ctor_encoding2()), "UTF-8") - } - -} diff --git a/inst/unitTests/runit.Vector.R b/inst/unitTests/runit.Vector.R deleted file mode 100644 index a3ec77fdf..000000000 --- a/inst/unitTests/runit.Vector.R +++ /dev/null @@ -1,780 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# Copyright (C) 2010 - 2018 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("Vector.cpp") - - test.RawVector <- function(){ - funx <- raw_ - checkEquals( funx(), as.raw(0:9), msg = "RawVector(int)" ) - } - - test.RawVector.REALSXP <- function(){ - funx <- raw_REALSXP - checkEquals( funx(as.raw(0:9)), as.raw(2*0:9), msg = "RawVector( RAWSXP) " ) - } - - test.ExpressionVector <- function(){ - funx <- expression_ - ex <- parse( text = "rnorm; rnorm(10)" ) - # get rid of the srcref stuff so that we can compare - # more easily - attributes(ex) <- NULL - checkEquals( funx(), ex , msg = "ExpressionVector" ) - } - - test.ExpressionVector.variadic <- function(){ - funx <- expression_variadic - ex <- parse( text = "rnorm; rnorm(10)" ) - attributes(ex) <- NULL - checkEquals( funx(), ex , msg = "ExpressionVector (using variadic templates) " ) - } - - test.ExpressionVector.parse <- function( ){ - funx <- expression_parse - code <- funx() - results <- eval( code ) - checkEquals( results, 1:10, msg = "ExpressionVector parsing" ) - } - - test.ExpressionVector.parse.error <- function(){ - funx <- expression_parseerror - checkException( funx(), msg = "parse error" ) - } - - test.ExpressionVector.eval <- function(){ - funx <- expression_eval - checkEquals( funx(), 1:10, msg = "ExpressionVector::eval" ) - } - - test.ExpressionVector.eval.env <- function(){ - funx <- expression_evalenv - e <- new.env() - e[["x"]] <- sample(1:10) - checkEquals( funx(e), 1:10, msg = "ExpressionVector::eval in specific environment" ) - } - - test.ComplexVector <- function(){ - funx <- complex_ - checkEquals( funx(), 0:9*(1+1i), msg = "ComplexVector" ) - } - test.ComplexVector.CPLXSXP <- function(){ - funx <- complex_CPLXSXP - vv = (0:9)*(1+1i) ## not working - funx changes its argument - #checkEquals( funx(vv), 2*vv, msg = "ComplexVector( CPLXSXP) " ) - checkEquals( funx((0:9)*(1+1i)), 2*(0:9)*(1+1i), msg = "ComplexVector( CPLXSXP) " ) - } - test.ComplexVector.INTSXP <- function(){ - funx <- complex_INTSXP - vv <- 0L:9L - checkEquals( funx(vv), (2+0i)*vv, msg = "ComplexVector( INTSXP) " ) - } - test.ComplexVector.REALSXP <- function(){ - funx <- complex_REALSXP - vv <- as.numeric(0:9) - checkEquals( funx(vv), (3+0i)*vv, msg = "ComplexVector( REALSXP) " ) - } - - - - - test.IntegerVector <- function(){ - fun <- integer_ctor - checkEquals( fun(), 0:9, msg = "IntegerVector" ) - } - - test.IntegerVector.INTSXP_ <- function(){ - fun <- integer_INTSXP - checkEquals( fun(0:9), 2*0:9, msg = "IntegerVector( INTSXP) " ) - } - - - test.IntegerVector.Dimension.constructor <- function(){ - fun <- integer_dimension_ctor_1 - checkEquals(fun(), - integer(5) , - msg = "IntegerVector( Dimension(5))" ) - - fun <- integer_dimension_ctor_2 - checkEquals(fun(), - matrix( 0L, ncol = 5, nrow = 5) , - msg = "IntegerVector( Dimension(5,5))" ) - - fun <- integer_dimension_ctor_3 - checkEquals(fun(), - array( 0L, dim = c(2,3,4) ) , - msg = "IntegerVector( Dimension(2,3,4))" ) - } - - test.IntegerVector.range.constructors <- function(){ - fun <- integer_range_ctor_1 - checkEquals( fun(), 0:3, msg = "assign(int*, int*)" ) - - fun <- integer_range_ctor_2 - checkEquals( fun(), 0:3, msg = "assign(int*, int*)" ) - } - - test.IntegerVector.names.set <- function(){ - fun <- integer_names_set - checkEquals(names(fun()), c("foo", "bar"), msg = "Vector::names" ) - } - - test.IntegerVector.names.get <- function(){ - fun <- integer_names_get - checkEquals(fun( c("foo" = 1L, "bar" = 2L) ), - c("foo", "bar"), - msg = "Vector::names get" ) - } - - test.IntegerVector.names.indexing <- function(){ - fun <- integer_names_indexing - x <- c( "foo" = 1L, "bar" = 2L ) - checkEquals( fun( x ), 1L, msg = "IntegerVector names based indexing" ) - } - - test.IntegerVector.push.back <- function(){ - fun <- integer_push_back - checkEquals( fun(1:4), 1:5, msg = "IntegerVector push back" ) - - x <- 1:4 - names(x) <- letters[1:4] - - target <- 1:5 - names(target) <- c( letters[1:4], "") - checkEquals( fun(x), target, msg = "IntegerVector push back names" ) - } - - test.IntegerVector.push.front <- function(){ - fun <- integer_push_front - checkEquals( fun(1:4), c(5L,1:4), msg = "IntegerVector push front" ) - - x <- 1:4 - names(x) <- letters[1:4] - - target <- c( 5L, 1:4 ) - names(target) <- c( "", letters[1:4]) - - checkEquals( fun(x), target, msg = "IntegerVector push front names" ) - } - - test.IntegerVector.insert <- function(){ - fun <- integer_insert - checkEquals( fun(1:4), c(5L,1L, 7L, 2:4), msg = "IntegerVector insert" ) - - x <- 1:4 - names(x) <- letters[1:4] - - target <- c( 5L, 1L, 7L, 2:4 ) - names(target) <- c( "", "a", "", letters[2:4]) - - checkEquals( fun(x), target, msg = "IntegerVector insert names" ) - } - - test.IntegerVector.erase <- function(){ - fun <- integer_erase - checkEquals( fun(1:4), c(1L, 2L, 4L), msg = "IntegerVector erase" ) - - x <- 1:4 - names(x) <- letters[1:4] - - target <- c(1L, 2L, 4L) - names(target) <- c( "a", "b", "d" ) - - checkEquals( fun(x), target, msg = "IntegerVector erase" ) - } - - test.IntegerVector.erase.range <- function(){ - x <- y <- 1:10 - names(y) <- letters[1:10] - res <- integer_erase_range( x, y ) - checkEquals( res[[1L]], c(1:5, 10L) , msg = "IntegerVector erase range unnamed" ) - - z <- y[-(6:9)] - checkEquals( res[[2L]], z , msg = "IntegerVector erase range named" ) - } - - test.IntegerVector.erase.range.2 <- function(){ - x <- y <- 1:10 - names(y) <- letters[1:10] - res <- integer_erase_range_2( x, y ) - checkEquals( res[[1L]], 1L , msg = "IntegerVector erase range 2 unnamed" ) - checkEquals( res[[2L]], c("a" = 1L ) , msg = "IntegerVector erase range 2 named" ) - } - - - test.IntegerVector.erase.range.2 <- function(){ - x <- y <- as.list(1:10) - names(y) <- letters[1:10] - res <- List_erase_range_2( x, y ) - checkEquals( res[[1L]], list( 1L ) , msg = "List erase range 2 unnamed" ) - checkEquals( res[[2L]], list("a" = 1L ) , msg = "List erase range 2 named" ) - } - - test.IntegerVector.erase2 <- function(){ - checkEquals( integer_erase2(1:4), c(1L, 3L, 4L), msg = "IntegerVector erase2" ) - - x <- 1:4 - names(x) <- letters[1:4] - - target <- c(1L, 3L, 4L) - names(target) <- c( "a", "c", "d" ) - - checkEquals( integer_erase2(x), target, msg = "IntegerVector erase2" ) - } - - test.IntegerVector.fill <- function(){ - fun <- integer_fill - x <- 1:10 - checkEquals( fun(x), rep(10L, 10 ), msg = "IntegerVector.fill" ) - } - - test.IntegerVector.zero <- function( ){ - fun <- integer_zero - checkEquals( fun(), integer(0), msg = "IntegerVector(0)" ) - } - - test.IntegerVector.create.zero <- function( ){ - fun <- integer_create_zero - checkEquals( fun(), integer(0), msg = "IntegerVector::create()" ) - } - - test.IntegerVector.create <- function(){ - fun <- integer_create_ - checkEquals( fun(), list( c( 10L, 20L) , c(foo = 20L, bar = 30L) ), - msg = "IntegerVector::create" ) - } - - test.IntegerVector.clone <- function(){ - x <- 1:10 - fun <- integer_clone_ - y <- fun(x) - checkEquals( x, 1:10, msg = "clone" ) - checkEquals( y, 10:1, msg = "clone" ) - } - - - - - - test.NumericVector <- function(){ - funx <- numeric_ - checkEquals( funx(), as.numeric(0:9), msg = "NumericVector(int)" ) - } - - test.NumericVector.REALSXP <- function(){ - funx <- numeric_REALSXP - checkEquals( funx(as.numeric(0:9)), 2*0:9, msg = "NumericVector( REALSXP) " ) - } - - - test.NumericVector.import <- function(){ - funx <- numeric_import - checkEquals( funx(), 0:9, msg = "IntegerVector::import" ) - } - - test.NumericVector.import.transform <- function(){ - funx <- numeric_importtransform - checkEquals( funx(), (0:9)^2, msg = "NumericVector::import_transform" ) - } - - - - - - test.List <- function(){ - fun <- list_ctor - checkEquals( fun(), as.list( 2*0:9), msg = "GenericVector" ) - } - - test.List.template <- function(){ - fun <- list_template_ - checkEquals(fun(), list( "foo", 10L, 10.2, FALSE), msg = "GenericVector" ) - } - - test.List.VECSXP <- function(){ - fun <- list_VECSXP_ - checkEquals( fun(list(1,2)), list(1,2), msg = "GenericVector( VECSXP) " ) - } - - test.List.matrix.indexing <- function(){ - fun <- list_matrix_indexing_1 - ## a matrix of integer vectors - x <- structure( lapply( 1:16, function(x) seq.int(x) ), dim = c( 4, 4) ) - checkEquals( fun(x), diag(x), msg = "matrix indexing 1" ) - - fun <- list_matrix_indexing_2 - checkEquals(diag(fun(x)), rep(list("foo"), 4) , msg = "matrix indexing lhs" ) - - ## drop dimensions - dim(x) <- NULL - checkException( fun(x) , msg = "not a matrix" ) - } - - test.List.Dimension.constructor <- function(){ - fun <- list_Dimension_constructor_1 - checkEquals(fun(), - rep(list(NULL),5) , - msg = "List( Dimension(5))" ) - - fun <- list_Dimension_constructor_2 - checkEquals(fun(), - structure( rep( list(NULL), 25), dim = c(5,5) ), - msg = "List( Dimension(5,5))" ) - - fun <- list_Dimension_constructor_3 - checkEquals(fun(), - array( rep(list(NULL)), dim = c(2,3,4) ) , - msg = "List( Dimension(2,3,4))" ) - } - - test.List.iterator <- function() { - fun <- list_iterator_ - data <- list( x = letters, y = LETTERS, z = 1:4 ) - checkEquals(fun( data, length ), - list( x = 26L, y = 26L, z = 4L), - msg = "c++ version of lapply" ) - } - - test.List.name.indexing <- function(){ - fun <- list_name_indexing - d <- data.frame( x = 1:10, y = letters[1:10] ) - checkEquals( fun( d ), sum(1:10), msg = "List names based indexing" ) - } - - test.List.push.back <- function(){ - fun <- list_push_back - d <- list( x = 1:10, y = letters[1:10] ) - checkEquals(fun( d ), - list( x = 1:10, y = letters[1:10], 10L, foo = "bar" ), - msg = "List.push_back" ) - } - - test.List.push.front <- function(){ - fun <- list_push_front - d <- list( x = 1:10, y = letters[1:10] ) - checkEquals(fun(d), - list( foo = "bar", 10L, x = 1:10, y = letters[1:10] ), - msg = "List.push_front" ) - } - - test.List.erase <- function(){ - fun <- list_erase - d <- list( x = 1:10, y = letters[1:10] ) - checkEquals(fun(d), - list( y = letters[1:10] ), - msg = "List.erase" ) - } - - test.List.erase.range <- function(){ - fun <- list_erase_range - d <- list( x = 1:10, y = letters[1:10], z = 1:10 ) - checkEquals(fun(d), - list( z = 1:10 ), - msg = "List.erase (range version)" ) - } - - test.List.implicit.push.back <- function(){ - fun <- list_implicit_push_back - checkEquals( fun(), list( foo = 10, bar = "foobar" ), msg = "List implicit push back" ) - } - - test.List.create <- function(){ - fun <- list_create_ - checkEquals( fun(), list( list( 10L, "foo" ), list(foo = 10L, bar = TRUE ) ), - msg = "List::create" ) - } - - test.List.stdcomplex <- function(){ - fun <- list_stdcomplex - checkEquals( - fun(), - list( float = rep(0+0i, 10), double = rep(0+0i, 10) ), - msg = "range wrap over std::complex" ) - } - - - - - - test.CharacterVector <- function(){ - fun <- character_ctor - checkEquals( fun(), rep("foo",10L), msg = "CharacterVector" ) - } - - test.CharacterVector.STRSXP <- function(){ - fun <- character_STRSXP_ - checkEquals( fun(letters), paste(letters,collapse="" ), msg = "CharacterVector( STRSXP) " ) - } - - - test.CharacterVector.plusequals <- function(){ - fun <- character_plusequals - checkEquals( fun(), c("foobar", "barfoobar"), msg = "StringProxy::operator+=" ) - } - - test.CharacterVector.matrix.indexing <- function() { - fun <- character_matrix_indexing - x <- matrix( as.character(1:16), ncol = 4 ) - checkEquals( fun(x), paste(diag(x), collapse = ""), msg = "matrix indexing" ) - - y <- as.vector( x ) - checkException( fun(y) , msg = "not a matrix" ) - - fun <- character_matrix_indexing_lhs - checkEquals( diag(fun(x)), rep("foo", 4) , msg = "matrix indexing lhs" ) - } - - test.CharacterVector.matrix.row.iteration <- function() { - x <- matrix(letters[1:16], nrow = 4) - - fun <- character_matrix_row_iteration_incr - checkEquals( fun(x), "bfjn", msg = "matrix row iteration post-incr" ) - - fun <- character_matrix_row_iteration_decr - checkEquals( fun(x), "njf", msg = "matrix row iteration post-decr" ) - } - - test.CharacterVector.assign <- function(){ - fun <- character_assign1 - checkEquals( fun(), c("foo", "bar", "bling", "boom"), msg = "assign(char**, char**)" ) - - fun <- character_assign2 - checkEquals( fun(), c("foo", "bar", "bling", "boom"), msg = "assign(char**, char**)" ) - - } - - test.CharacterVector.range.constructors <- function(){ - fun <- character_range_ctor1 - checkEquals( fun(), c("foo", "bar", "bling", "boom"), msg = "assign(char**, char**)" ) - - fun <- character_range_ctor2 - checkEquals( fun(), c("foo", "bar", "bling", "boom"), msg = "assign(char**, char**)" ) - } - - test.CharacterVector.Dimension.constructor <- function(){ - fun <- character_dimension_ctor1 - checkEquals(fun(), - character(5), - msg = "CharacterVector( Dimension(5))" ) - - fun <- character_dimension_ctor2 - checkEquals(fun(), - matrix( "", ncol = 5, nrow = 5), - msg = "CharacterVector( Dimension(5,5))" ) - - fun <- character_dimension_ctor3 - checkEquals(fun(), - array( "", dim = c(2,3,4) ) , - msg = "CharacterVector( Dimension(2,3,4))" ) - } - - test.CharacterVector.iterator <- function(){ - fun <- character_iterator1 - checkEquals(fun(letters), - paste(letters, collapse=""), - msg = "CharacterVector::iterator explicit looping" ) - - fun <- character_iterator2 - checkEquals(fun(letters), - paste(letters, collapse=""), - msg = "CharacterVector::iterator using std::accumulate" ) - } - - test.CharacterVector.iterator <- function(){ - fun <- character_const_iterator1 - checkEquals(fun(letters), - paste(letters, collapse=""), - msg = "CharacterVector::iterator explicit looping" ) - - fun <- character_const_iterator2 - checkEquals(fun(letters), - paste(letters, collapse=""), - msg = "CharacterVector::iterator using std::accumulate" ) - } - - test.CharacterVector.reverse <- function(){ - fun <- character_reverse - x <- c("foo", "bar", "bling") - x <- fun(x) - checkEquals( x, c("bling", "bar", "foo"), msg = "reverse" ) - x <- fun(x) - checkEquals( x, c("foo", "bar", "bling"), msg = "reverse" ) - } - - test.CharacterVector.names.indexing <- function(){ - fun <- character_names_indexing - x <- c( foo = "foo", bar = "bar" ) - checkEquals( fun(x), "foo", msg = "CharacterVector names based indexing" ) - } - - test.CharacterVector.listOf <- function() { - fun <- character_listOf - checkEquals(fun(list(foo=c("tic","tac","toe"), - bar=c("Eenie","Meenie","Moe"))), - list(foo="tictactoe", bar="EenieMeenieMoe"), - msg="CharacterVector from list") - } - - test.CharacterVector.find <- function(){ - fun <- character_find_ - checkEquals( fun( c("bar", "foo", "bob") ), 1L, msg = "support for std::find in CharacterVector" ) - } - - test.CharacterVector.create <- function(){ - fun <- character_create_ - checkEquals( fun(), list( c( "foo", "bar" ), c(foo = "bar", bar = "foo" ) ), - msg = "CharacterVector::create" ) - } - - test.ComplexVector.binary.operators <- function(){ - fun <- complex_binary_sugar - x <- (1+1i) * 1:10 - y <- (2-3i) * 1:10 - - checkEquals( - fun(x, y), - list( - "+" = x + y, - "-" = x - y, - "*" = x * y, - "/" = x / y - ), msg = "complex binary operators" ) - } - - test.ComplexVector.binary.operators <- function(){ - fun <- List_extract - checkEquals( fun(list(TRUE, 4)), list(TRUE, 4L) ) - checkEquals( fun(list(FALSE, -4L)), list(FALSE,-4L) ) - } - - test.factors <- function(){ - fun <- factors - x <- as.factor( c("c3", "c2", "c1") ) - y <- fun(x) - checkEquals( y, as.character(x) ) - } - - test.IntegerVector_int_init <- function(){ - fun <- IntegerVector_int_init - checkEquals( fun(), c(4L,4L), msg = "IntegerVector int init regression test" ) - } - - test.containsElementNamed <- function() { - fun <- containsElementNamed - - x <- list( foo = 2, bla = 1:10 ) - - checkEquals(fun(x, "foo"), TRUE, msg = "containsElementNamed with element") - checkEquals(fun(x, "bar"), FALSE, msg = "containsElementNamed without element") - checkEquals(fun(x, ""), FALSE, msg = "containsElementNamed with empty element") - } - - test.CharacterVector.equality.operator <- function(){ - res <- CharacterVectorEqualityOperator( letters, letters ) - checkEquals( res, - list( rep( TRUE, 26L ), rep( FALSE, 26L) ), - msg = 'CharacterVector element equality operator' ) - } - - test.List.rep.ctor <- function(){ - x <- 1:10 - res <- List_rep_ctor(x) - expected <- rep( list(x), 3 ) - checkEquals( res, expected, msg = "List rep constructor" ) - } - - test.std.vector.double <- function() { - fun <- stdVectorDouble - x <- seq(1.0, 5.0, by=1.0) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorDouble") - } - - test.std.vector.double.const <- function() { - fun <- stdVectorDoubleConst - x <- seq(1.0, 5.0, by=1.0) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorDoubleConst") - } - - test.std.vector.double.ref <- function() { - fun <- stdVectorDoubleRef - x <- seq(1.0, 5.0, by=1.0) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorDoubleRef") - } - - test.std.vector.double.const.ref <- function() { - fun <- stdVectorDoubleConstRef - x <- seq(1.0, 5.0, by=1.0) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorDoubleConstRef") - } - - test.std.vector.int <- function() { - fun <- stdVectorInt - x <- seq(1L, 5L, by=1L) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorInt") - } - - test.std.vector.int.const <- function() { - fun <- stdVectorIntConst - x <- seq(1L, 5L, by=1L) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorIntConst") - } - - test.std.vector.int.ref <- function() { - fun <- stdVectorIntRef - x <- seq(1L, 5L, by=1L) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorIntRef") - } - - test.std.vector.int.const.ref <- function() { - fun <- stdVectorIntConstRef - x <- seq(1L, 5L, by=1L) - checkEquals(fun(x), 5, msg = "automatic conversion of stdVectorIntConstRef") - } - - test.character.vector.const.proxy <- function(){ - res <- character_vector_const_proxy( "fooo" ) - checkEquals( res, "fooo", msg = "CharacterVector const proxy. #32" ) - } - - test.CharacterVector.test.const.proxy <- function(){ - res <- CharacterVector_test_const_proxy( letters ) - checkEquals( res, letters ) - } - - test.sort <- function() { - num <- setNames( c(1, -1, 4, NA, 5, NaN), letters[1:5] ) - checkIdentical( sort_numeric(num), sort(num, na.last=TRUE) ) - int <- as.integer(num) - checkIdentical( sort_integer(int), sort(int, na.last=TRUE) ) - char <- setNames( sample(letters, 5), LETTERS[1:5] ) - checkIdentical( sort_character(char), sort(char, na.last=TRUE) ) - lgcl <- as.logical(int) - checkIdentical( sort_logical(lgcl), sort(lgcl, na.last=TRUE) ) - } - - test.sort_desc <- function() { - num <- setNames(c(1, -1, 4, NA, 5, NaN), letters[1:5]) - checkIdentical( - sort_numeric_desc(num), - sort(num, decreasing = TRUE, na.last = FALSE) - ) - - int <- as.integer(num) - checkIdentical( - sort_integer_desc(int), - sort(int, decreasing = TRUE, na.last = FALSE) - ) - - char <- setNames(sample(letters, 5), LETTERS[1:5]) - checkIdentical( - sort_character_desc(char), - sort(char, decreasing = TRUE, na.last = FALSE) - ) - - lgcl <- as.logical(int) - checkIdentical( - sort_logical_desc(lgcl), - sort(lgcl, decreasing = TRUE, na.last = FALSE) - ) - } - - test.List.assign.SEXP <- function() { - l <- list(1, 2, 3) - other <- list_sexp_assign(l) - checkIdentical(l, other) - } - - test.logical.vector.from.bool <- function() { - checkIdentical(logical_vector_from_bool(), TRUE) - } - - test.logical.vector.from.bool.assign <- function() { - checkIdentical(logical_vector_from_bool_assign(), TRUE) - } - - test.noprotect_vector <- function(){ - x <- rnorm(10) - checkIdentical( noprotect_vector(x), 10L ) - } - - test.noprotect_matrix <- function(){ - x <- matrix(rnorm(10), nrow=2) - checkIdentical( noprotect_matrix(x), 2L ) - } - - test.IntegerVector.accessor.with.bounds.checking <- function() { - x <- seq(1L, 5L, by=1L) - checkEquals(vec_access_with_bounds_checking(x, 3), 4) - checkException(vec_access_with_bounds_checking(x, 5) , msg = "index out of bounds not detected" ) - checkException(vec_access_with_bounds_checking(x, -1) , msg = "index out of bounds not detected" ) - } - - test.NumericVector.print <- function() { - v <- c(1.1, 2.2, 3.3, 4.4) - s <- vec_print_numeric(v) - checkEquals(s, "1.1 2.2 3.3 4.4") - } - - test.IntegerVector.print <- function() { - v <- c(1, 2, 3, 4) - s <-vec_print_integer(v) - checkEquals(s, "1 2 3 4") - } - - test.CharacterVector.print <- function() { - v <- c("a", "b", "c", "d") - s <- vec_print_character(v) - checkEquals(s, '"a" "b" "c" "d"') - } - - test.IntegerVector.subset.under.gc <- function() { - x <- 1:1E6 - y <- 1:1E6 - gctorture(TRUE) - z <- vec_subset(x, y) - gctorture(FALSE) - checkEquals(x[y], z) - } - - test.CharacterVectorNoProtect <- function(){ - s <- "foo" - checkEquals(CharacterVectorNoProtect(s), 1L) - checkEquals(s, "") - } - - test.CharacterVectorNoProtect_crosspolicy <- function(){ - s <- "foo" - checkEquals(CharacterVectorNoProtect_crosspolicy(s), s) - } - - test.ListNoProtect_crosspolicy <- function(){ - data <- list(1:10) - data2 <- ListNoProtect_crosspolicy(data) - checkEquals(data, data2) - } - - test.CharacterVector_test_equality <- function(){ - checkTrue( !CharacterVector_test_equality("foo", "bar") ) - checkTrue( !CharacterVector_test_equality_crosspolicy("foo", "bar") ) - } -} diff --git a/inst/unitTests/runit.VectorOld.R b/inst/unitTests/runit.VectorOld.R deleted file mode 100644 index 3c5d8fc27..000000000 --- a/inst/unitTests/runit.VectorOld.R +++ /dev/null @@ -1,34 +0,0 @@ -# Copyright (C) 2014 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("VectorOld.cpp") - - test.IntegerVector.comma <- function(){ - fun <- integer_comma - checkEquals( fun(), 0:3, msg = "IntegerVector comma initialization" ) - } - - test.CharacterVector.comma <- function(){ - fun <- character_comma - checkEquals( fun(), c("foo","bar", "bling" ), msg = "CharacterVector comma operator" ) - } - -} diff --git a/inst/unitTests/runit.XPTr.R b/inst/unitTests/runit.XPTr.R deleted file mode 100644 index 3e9d76f0e..000000000 --- a/inst/unitTests/runit.XPTr.R +++ /dev/null @@ -1,43 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# Copyright (C) 2009 - 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("XPtr.cpp") - - test.XPtr <- function(){ - xp <- xptr_1() - checkEquals(typeof( xp ), "externalptr", msg = "checking external pointer creation" ) - - front <- xptr_2(xp) - checkEquals( front, 1L, msg = "check usage of external pointer" ) - - checkTrue(xptr_release(xp), msg = "check release of external pointer") - - checkTrue(xptr_access_released(xp), msg = "check access of released external pointer") - - checkException(xptr_use_released(xp), - msg = "check exception on use of released external pointer", - silent = TRUE) - } - -} diff --git a/inst/unitTests/runit.algorithm.R b/inst/unitTests/runit.algorithm.R deleted file mode 100644 index f70ce2f5d..000000000 --- a/inst/unitTests/runit.algorithm.R +++ /dev/null @@ -1,148 +0,0 @@ -#!/usr/bin/r -t -# -# Copyright (C) 2010 - 2015 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("algorithm.cpp") - - test.sum <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(sum(v), sumTest(v, 1, 5)) - v <- c(NA, 1.0, 2.0, 3.0, 4.0) - checkEquals(sum(v), sumTest(v, 1, 5)) - } - - test.sum.nona <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(sum(v), sumTest_nona(v, 1, 5)) - } - - test.prod <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(prod(v), prodTest(v, 1, 5)) - v <- c(NA, 1.0, 2.0, 3.0, 4.0) - checkEquals(prod(v), prodTest(v, 1, 5)) - } - - test.prod.nona <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(prod(v), prodTest_nona(v, 1, 5)) - } - - test.log <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(log(v), logTest(v)) - v <- c(NA, 1.0, 2.0, 3.0, 4.0) - checkEquals(log(v), logTest(v)) - } - - test.exp <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(exp(v), expTest(v)) - v <- c(NA, 1.0, 2.0, 3.0, 4.0) - checkEquals(exp(v), expTest(v)) - } - - test.sqrt <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(sqrt(v), sqrtTest(v)) - v <- c(NA, 1.0, 2.0, 3.0, 4.0) - checkEquals(sqrt(v), sqrtTest(v)) - } - - test.min <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(min(v), minTest(v)) - v <- c(NA, 1.0, 2.0, 3.0, 4.0) - checkEquals(min(v), minTest(v)) - } - - test.min.nona <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(min(v), minTest_nona(v)) - } - - test.min.int <- function() { - v <- c(1, 2, 3, 4, 5) - checkEquals(min(v), minTest_int(v)) - v <- c(NA, 1, 2, 3, 4) - checkEquals(min(v), minTest_int(v)) - } - - test.min.int.nona <- function() { - v <- c(1, 2, 3, 4, 5) - checkEquals(min(v), minTest_int_nona(v)) - } - - test.max <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(max(v), maxTest(v)) - v <- c(NA, 1.0, 2.0, 3.0, 4.0) - checkEquals(max(v), maxTest(v)) - } - - test.max.nona <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(max(v), maxTest_nona(v)) - } - - test.max.int <- function() { - v <- c(1, 2, 3, 4, 5) - checkEquals(max(v), maxTest_int(v)) - v <- c(NA, 1, 2, 3, 4) - checkEquals(max(v), maxTest_int(v)) - } - - test.max.int.nona <- function() { - v <- c(1, 2, 3, 4, 5) - checkEquals(max(v), maxTest_int_nona(v)) - } - - test.mean <- function() { - v <- c(1.0, 2.0, 3.0, 4.0, 5.0) - checkEquals(mean(v), meanTest(v)) - v <- c(1.0, 2.0, 3.0, 4.0, NA) - checkEquals(mean(v), meanTest(v)) - v <- c(1.0, 2.0, 3.0, 4.0, NaN) - checkEquals(mean(v), meanTest(v)) - v <- c(1.0, 2.0, 3.0, 4.0, 1.0/0.0) - checkEquals(mean(v), meanTest(v)) - v <- c(1.0, 2.0, 3.0, 4.0, -1.0/0.0) - checkEquals(mean(v), meanTest(v)) - v <- c(1.0, 2.0, 1.0/0.0, NA, NaN) - checkEquals(mean(v), meanTest(v)) - v <- c(1.0, 2.0, 1.0/0.0, NaN, NA) - } - - test.mean.int <- function() { - v <- c(1, 2, 3, 4, 5) - checkEquals(mean(v), meanTest_int(v)) - v <- c(1, 2, 3, 4, NA) - checkEquals(mean(v), meanTest_int(v)) - } - - test.mean.logical <- function() { - v <- c(TRUE, FALSE, FALSE) - checkEquals(mean(v), meanTest_logical(v)) - v <- c(TRUE, FALSE, FALSE, NA) - checkEquals(mean(v), meanTest_logical(v)) - } -} diff --git a/inst/unitTests/runit.as.R b/inst/unitTests/runit.as.R deleted file mode 100644 index 822a1ee32..000000000 --- a/inst/unitTests/runit.as.R +++ /dev/null @@ -1,99 +0,0 @@ -#!/usr/bin/env r -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("as.cpp") - - test.as.int <- function(){ - checkEquals( as_int(10), 10L, msg = "as( REALSXP ) " ) - checkEquals( as_int(10L), 10L, msg = "as( INTSXP ) " ) - checkEquals( as_int(as.raw(10L)), 10L, msg = "as( RAWSXP ) " ) - checkEquals( as_int(TRUE), 1L, msg = "as( LGLSXP ) " ) - } - - test.as.double <- function(){ - checkEquals( as_double(10), 10.0, msg = "as( REALSXP ) " ) - checkEquals( as_double(10L), 10.0, msg = "as( INTSXP ) " ) - checkEquals( as_double(as.raw(10L)), 10.0, msg = "as( RAWSXP ) " ) - checkEquals( as_double(TRUE), 1.0, msg = "as( LGLSXP ) " ) - } - - test.as.raw <- function(){ - checkEquals( as_raw(10), as.raw(10), msg = "as( REALSXP ) " ) - checkEquals( as_raw(10L), as.raw(10), msg = "as( INTSXP ) " ) - checkEquals( as_raw(as.raw(10L)), as.raw(10), msg = "as( RAWSXP ) " ) - checkEquals( as_raw(TRUE), as.raw(1), msg = "as( LGLSXP ) " ) - } - - test.as.bool <- function(){ - checkEquals( as_bool(10), as.logical(10), msg = "as( REALSXP ) " ) - checkEquals( as_bool(10L), as.logical(10), msg = "as( INTSXP ) " ) - checkEquals( as_bool(as.raw(10L)), as.logical(10), msg = "as( RAWSXP ) " ) - checkEquals( as_bool(TRUE), as.logical(1), msg = "as( LGLSXP ) " ) - } - - test.as.string <- function(){ - checkEquals( as_string("foo"), "foo", msg = "as( STRSXP ) " ) - } - - test.as.vector.int <- function(){ - checkEquals( as_vector_int(1:10), 1:10 , msg = "as>( INTSXP ) " ) - checkEquals( as_vector_int(as.numeric(1:10)), 1:10 , msg = "as>( REALSXP ) " ) - checkEquals( as_vector_int(as.raw(1:10)), 1:10 , msg = "as>( RAWSXP ) " ) - checkEquals( as_vector_int(c(TRUE,FALSE)), 1:0 , msg = "as>( LGLSXP ) " ) - } - - test.as.vector.double <- function(){ - checkEquals( as_vector_double(1:10), as.numeric(1:10) , msg = "as>( INTSXP ) " ) - checkEquals( as_vector_double(as.numeric(1:10)), as.numeric(1:10) , msg = "as>( REALSXP ) " ) - checkEquals( as_vector_double(as.raw(1:10)), as.numeric(1:10), msg = "as>( RAWSXP ) " ) - checkEquals( as_vector_double(c(TRUE,FALSE)), c(1.0, 0.0) , msg = "as>( LGLSXP ) " ) - } - - test.as.vector.raw <- function(){ - checkEquals( as_vector_raw(1:10), as.raw(1:10) , msg = "as>( INTSXP ) " ) - checkEquals( as_vector_raw(as.numeric(1:10)), as.raw(1:10) , msg = "as>( REALSXP ) " ) - checkEquals( as_vector_raw(as.raw(1:10)), as.raw(1:10) , msg = "as>( RAWSXP ) " ) - checkEquals( as_vector_raw(c(TRUE,FALSE)), as.raw(1:0) , msg = "as>( LGLSXP ) " ) - } - - test.as.vector.bool <- function(){ - checkEquals( as_vector_bool(0:10), as.logical(0:10) , msg = "as>( INTSXP ) " ) - checkEquals( as_vector_bool(as.numeric(0:10)), as.logical(0:10) , msg = "as>( REALSXP ) " ) - checkEquals( as_vector_bool(as.raw(0:10)), as.logical(0:10) , msg = "as>( RAWSXP ) " ) - checkEquals( as_vector_bool(c(TRUE,FALSE)), as.logical(1:0) , msg = "as>( LGLSXP ) " ) - } - - - test.as.vector.string <- function(){ - checkEquals( as_vector_string(letters), letters , msg = "as>( STRSXP ) " ) - } - - test.as.deque.int <- function(){ - checkEquals( as_deque_int(1:10), 1:10 , msg = "as>( INTSXP ) " ) - } - - test.as.list.int <- function(){ - checkEquals( as_list_int(1:10), 1:10 , msg = "as>( INTSXP ) " ) - } - -} diff --git a/inst/unitTests/runit.attributes.R b/inst/unitTests/runit.attributes.R deleted file mode 100644 index b9f55a216..000000000 --- a/inst/unitTests/runit.attributes.R +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2014 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("attributes.cpp") - test.attributes <- function() { - checkEquals( - comments_test(), - "Start a C++ line comment with the characters \"//\"" - ) - checkEquals( - parse_declaration_test(), - "Parse function declaration" - ) - } - -} diff --git a/inst/unitTests/runit.binary.package.R b/inst/unitTests/runit.binary.package.R deleted file mode 100644 index 27b8f0cc0..000000000 --- a/inst/unitTests/runit.binary.package.R +++ /dev/null @@ -1,64 +0,0 @@ -#!/usr/bin/env r -# -# Copyright (C) 2014 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 . - -.onLinux <- .Platform$OS.type == "unix" && unname(Sys.info()["sysname"]) == "Linux" - -.onTravis <- Sys.getenv("TRAVIS") != "" - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -test.binary.testRcppPackage <- function() { - - if (.runThisTest && .onLinux && .onTravis) { - - debpkg <- "r-cran-testrcpppackage" - rpkg <- "testRcppPackage" - - ## R calls it i686 or x86_64; Debian/Ubuntu call it i386 or amd64 - arch <- switch(unname(Sys.info()["machine"]), "i686"="i386", "x86_64"="amd64") - - ## filename of pre-built - debfile <- file.path(system.file("unitTests/bin", package="Rcpp"), - arch, - paste0(debpkg, "_0.1.0-1_", arch, ".deb")) - - if (file.exists(debfile)) { - system(paste("sudo dpkg -i", debfile)) - - ## R> testRcppPackage:::rcpp_hello_world() - ## [[1]] - ## [1] "foo" "bar" - - ## [[2]] - ## [1] 0 1 - - ## R> - - require(rpkg, lib.loc = "/usr/lib/R/site-library", character.only = TRUE) - hello_world <- get("rcpp_hello_world", asNamespace(rpkg)) - - checkEquals(hello_world(), list(c("foo", "bar"), c(0.0, 1.0)), - msg = "code from binary package") - - system(paste("sudo dpkg --purge", debpkg)) - } - } -} - - diff --git a/inst/unitTests/runit.client.package.R b/inst/unitTests/runit.client.package.R deleted file mode 100644 index 78ab99320..000000000 --- a/inst/unitTests/runit.client.package.R +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/env r -# -# 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 . - -## This now (Dec 2011) appears to fail on Windows -.onWindows <- .Platform$OS.type == "windows" - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -.client.package <- function(pkg = "testRcppPackage") { - td <- tempfile() - cwd <- getwd() - dir.create(td) - file.copy(system.file("unitTests", pkg, package = "Rcpp"), td, recursive = TRUE) - setwd(td) - on.exit( { setwd(cwd); unlink(td, recursive = TRUE) } ) - R <- shQuote(file.path( R.home(component = "bin"), "R")) - cmd <- paste(R, "CMD build", pkg) - system(cmd) - dir.create("templib") - install.packages(paste0(pkg, "_0.1.0.tar.gz"), "templib", repos = NULL, type = "source") - require(pkg, lib.loc = "templib", character.only = TRUE) - hello_world <- get("rcpp_hello_world", asNamespace(pkg)) - checkEquals(hello_world(), list(c("foo", "bar"), c(0.0, 1.0)), - msg = "code from client package") - - checkException(.Call("hello_world_ex", PACKAGE = pkg), msg = "exception in client package") -} - -if (.runThisTest && ! .onWindows) { - test.client.testRcppPackage <- function() { - .client.package("testRcppPackage") - } -} diff --git a/inst/unitTests/runit.dispatch.R b/inst/unitTests/runit.dispatch.R deleted file mode 100644 index f4a4cfec9..000000000 --- a/inst/unitTests/runit.dispatch.R +++ /dev/null @@ -1,92 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2009 - 2016 Dirk Eddelbuettel and Romain Francois -# Copyright (C) 2016 Dirk Eddelbuettel, Romain Francois and Nathan Russell -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - .setUp <- Rcpp:::unitTestSetup("dispatch.cpp") - - test.RawVector <- function() { - x <- as.raw(0:9) - checkEquals(first_el(x), x[1], msg = "RCPP_RETURN_VECTOR (raw)") - } - - test.ComplexVector <- function() { - x <- as.complex(0:9) - checkEquals(first_el(x), x[1], msg = "RCPP_RETURN_VECTOR (complex)") - } - - test.IntegerVector <- function() { - x <- as.integer(0:9) - checkEquals(first_el(x), x[1], msg = "RCPP_RETURN_VECTOR (integer)") - } - - test.NumericVector <- function() { - x <- as.numeric(0:9) - checkEquals(first_el(x), x[1], msg = "RCPP_RETURN_VECTOR (numeric)") - } - - test.ExpressionVector <- function() { - x <- expression(rnorm, rnorm(10), mean(1:10)) - checkEquals(first_el(x), x[1], msg = "RCPP_RETURN_VECTOR (expression)") - } - - test.GenericVector <- function() { - x <- list("foo", 10L, 10.2, FALSE) - checkEquals(first_el(x), x[1], msg = "RCPP_RETURN_VECTOR (list)") - } - - test.CharacterVector <- function() { - x <- as.character(0:9) - checkEquals(first_el(x), x[1], msg = "RCPP_RETURN_VECTOR (character)") - } - - test.RawMatrix <- function() { - x <- matrix(as.raw(0:9), ncol = 2L) - checkEquals(first_cell(x), x[1, 1, drop = FALSE], msg = "RCPP_RETURN_MATRIX (raw)") - } - - test.ComplexMatrix <- function() { - x <- matrix(as.complex(0:9), ncol = 2L) - checkEquals(first_cell(x), x[1, 1, drop = FALSE], msg = "RCPP_RETURN_MATRIX (complex)") - } - - test.IntegerMatrix <- function() { - x <- matrix(as.integer(0:9), ncol = 2L) - checkEquals(first_cell(x), x[1, 1, drop = FALSE], msg = "RCPP_RETURN_MATRIX (integer)") - } - - test.NumericMatrix <- function() { - x <- matrix(as.numeric(0:9), ncol = 2L) - checkEquals(first_cell(x), x[1, 1, drop = FALSE], msg = "RCPP_RETURN_MATRIX (numeric)") - } - - test.GenericMatrix <- function() { - x <- matrix(lapply(0:9, function(.) 0:9), ncol = 2L) - checkEquals(first_cell(x), x[1, 1, drop = FALSE], msg = "RCPP_RETURN_MATRIX (list)") - } - - test.CharacterMatrix <- function() { - x <- matrix(as.character(0:9), ncol = 2L) - checkEquals(first_cell(x), x[1, 1, drop = FALSE], msg = "RCPP_RETURN_MATRIX (character)") - } - -} diff --git a/inst/unitTests/runit.embeddedR.R b/inst/unitTests/runit.embeddedR.R deleted file mode 100644 index 466acb3b7..000000000 --- a/inst/unitTests/runit.embeddedR.R +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; ess-indent-level: 4; tab-width: 4; indent-tabs-mode: nil; -* -# -# Copyright (C) 2012 - 2016 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - test.embeddedR <- function() { - path <- file.path(system.file("unitTests", package = "Rcpp"), "cpp") - expectedVars <- c("foo", "x") - - # embeddedR.cpp exposes the function foo, R snippet calls foo - newEnv <- new.env(parent = baseenv()) - Rcpp::sourceCpp(file.path(path, "embeddedR.cpp"), - env = newEnv) - checkEquals(ls(newEnv), expectedVars, msg = " sourcing code in custom env") - - # R snippet in embeddedR2.cpp also contains a call to foo from previous cpp - newEnv2 <- new.env(parent = baseenv()) - checkException(Rcpp::sourceCpp(file.path(path, "embeddedR2.cpp"), env = newEnv2), - " not available in other env") - } -} diff --git a/inst/unitTests/runit.environments.R b/inst/unitTests/runit.environments.R deleted file mode 100644 index 2baec51b4..000000000 --- a/inst/unitTests/runit.environments.R +++ /dev/null @@ -1,307 +0,0 @@ -#!/usr/bin/env r -# hey emacs, please make this use -*- tab-width: 4 -*- -# -# Copyright (C) 2009 - 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("Environment.cpp") - - test.environment.ls <- function(){ - e <- new.env( ) - e$a <- 1:10 - e$b <- "foo" - e$.c <- "hidden" - checkEquals( sort(runit_ls(e)), sort(c("a","b", ".c")), msg = "Environment::ls(true)" ) - checkEquals( runit_ls(asNamespace("Rcpp")), ls(envir=asNamespace("Rcpp"), all = TRUE), - msg = "Environment(namespace)::ls()" ) - - checkEquals( runit_ls2(e), c("a","b"), msg = "Environment::ls(false)" ) - checkEquals( runit_ls2(asNamespace("Rcpp")), ls(envir=asNamespace("Rcpp"), all = FALSE), - msg = "Environment(namespace)::ls()" ) - - } - - test.environment.get <- function(){ - e <- new.env( ) - e$a <- 1:10 - e$b <- "foo" - - # Access with string - checkEquals( runit_get( e, "a" ), e$a, msg = "Environment::get(string)" ) - checkEquals( runit_get( e, "foobar" ), NULL, msg = "Environment::get(string)" ) - checkEquals( runit_get( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, - msg = "Environment(namespace)::get(string) " ) - - # Access with Symbol constructed on call from string - checkEquals( runit_get_symbol( e, "a" ), e$a, msg = "Environment::get(Symbol)" ) - checkEquals( runit_get_symbol( e, "foobar" ), NULL, msg = "Environment::get(Symbol)" ) - checkEquals( runit_get_symbol( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, - msg = "Environment(namespace)::get(Symbol) " ) - - } - - test.environment.find <- function(){ - e <- new.env( ) - e$a <- 1:10 - e$b <- "foo" - bar <- "me" - - # Access with string - checkEquals( runit_find( e, "a" ), e$a, msg = "Environment::find(string)" ) - checkException( runit_find( e, "foobar" ), NULL, msg = "Environment::find(string) not found" ) - checkEquals( runit_find( e, "bar"), bar, msg = "Environment::find(string) inheritance" ) - checkEquals( runit_find( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, - msg = "Environment(namespace)::find(string)" ) - - # Access with Symbol constructed on call from string - checkEquals( runit_find_symbol( e, "a" ), e$a, msg = "Environment::find(Symbol)" ) - checkException( runit_find_symbol( e, "foobar" ), NULL, msg = "Environment::find(Symbol) not found" ) - checkEquals( runit_find_symbol( e, "bar"), bar, msg = "Environment::find(Symbol) inheritance" ) - checkEquals( runit_find_symbol( asNamespace("Rcpp"), "CxxFlags"), Rcpp:::CxxFlags, - msg = "Environment(namespace)::find(Symbol)" ) - - } - - - test.environment.exists <- function(){ - e <- new.env( ) - e$a <- 1:10 - e$b <- "foo" - - checkTrue( runit_exists( e, "a" ), msg = "Environment::get()" ) - checkTrue( !runit_exists( e, "foobar" ), msg = "Environment::get()" ) - checkTrue( runit_exists( asNamespace("Rcpp"), "CxxFlags"), - msg = "Environment(namespace)::get() " ) - } - - test.environment.assign <- function(){ - e <- new.env( ) - checkTrue( runit_assign(e, "a", 1:10 ), msg = "Environment::assign" ) - checkTrue( runit_assign(e, "b", Rcpp:::CxxFlags ), msg = "Environment::assign" ) - checkEquals( ls(e), c("a", "b"), msg = "Environment::assign, checking names" ) - checkEquals( e$a, 1:10, msg = "Environment::assign, checking value 1" ) - checkEquals( e$b, Rcpp:::CxxFlags, msg = "Environment::assign, checking value 2" ) - - lockBinding( "a", e ) - can.demangle <- Rcpp:::capabilities()[["demangling"]] - if( can.demangle ){ - checkTrue( - tryCatch( { runit_assign(e, "a", letters ) ; FALSE}, "Rcpp::binding_is_locked" = function(e) TRUE ), - msg = "cannot assign to locked binding (catch exception)" ) - } else { - checkTrue( - tryCatch( { runit_assign(e, "a", letters ) ; FALSE}, "error" = function(e) TRUE ), - msg = "cannot assign to locked binding (catch exception)" ) - } - } - - test.environment.isLocked <- function(){ - e <- new.env() - runit_islocked(e) - checkEquals( e[["x1"]], 1L , msg = "Environment::assign( int ) " ) - checkEquals( e[["x2"]], 10.0, msg = "Environment::assign( double ) " ) - checkEquals( e[["x3"]], "foobar", msg = "Environment::assign( char* ) " ) - checkEquals( e[["x4"]], "foobar", msg = "Environment::assign( std::string ) " ) - checkEquals( e[["x5"]], c("foo", "bar" ), msg = "Environment::assign( vector ) " ) - } - - test.environment.bindingIsActive <- function(){ - e <- new.env() - e$a <- 1:10 - makeActiveBinding( "b", function(x) 10, e ) - - checkTrue( !runit_bindingIsActive(e, "a" ), msg = "Environment::bindingIsActive( non active ) -> false" ) - checkTrue( runit_bindingIsActive(e, "b" ), msg = "Environment::bindingIsActive( active ) -> true" ) - - can.demangle <- Rcpp:::capabilities()[["demangling"]] - if( can.demangle ){ - checkTrue( - tryCatch( { runit_bindingIsActive(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), - msg = "Environment::bindingIsActive(no binding) -> exception)" ) - } else { - checkTrue( - tryCatch( { runit_bindingIsActive(e, "xx" ) ; FALSE}, error = function(e) TRUE ), - msg = "Environment::bindingIsActive(no binding) -> exception)" ) - } - } - - test.environment.bindingIsLocked <- function(){ - e <- new.env() - e$a <- 1:10 - e$b <- letters - lockBinding( "b", e ) - - checkTrue( !runit_bindingIsLocked(e, "a" ), msg = "Environment::bindingIsActive( non active ) -> false" ) - checkTrue( runit_bindingIsLocked(e, "b" ), msg = "Environment::bindingIsActive( active ) -> true" ) - - can.demangle <- Rcpp:::capabilities()[["demangling"]] - if( can.demangle ){ - checkTrue( - tryCatch( { runit_bindingIsLocked(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), - msg = "Environment::bindingIsLocked(no binding) -> exception)" ) - } else { - checkTrue( - tryCatch( { runit_bindingIsLocked(e, "xx" ) ; FALSE}, error = function(e) TRUE ), - msg = "Environment::bindingIsLocked(no binding) -> exception)" ) - } - } - - test.environment.NotAnEnvironment <- function(){ - checkException( runit_notanenv( runit_notanenv ), msg = "not an environment" ) - checkException( runit_notanenv( letters ), msg = "not an environment" ) - checkException( runit_notanenv( NULL ), msg = "not an environment" ) - } - - - test.environment.lockBinding <- function(){ - e <- new.env() - e$a <- 1:10 - e$b <- letters - runit_lockbinding(e, "b") - checkTrue( bindingIsLocked("b", e ), msg = "Environment::lockBinding()" ) - - can.demangle <- Rcpp:::capabilities()[["demangling"]] - if( can.demangle ){ - checkTrue( - tryCatch( { runit_lockbinding(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), - msg = "Environment::lockBinding(no binding) -> exception)" ) - } else { - checkTrue( - tryCatch( { runit_lockbinding(e, "xx" ) ; FALSE}, error = function(e) TRUE ), - msg = "Environment::lockBinding(no binding) -> exception)" ) - } - } - - test.environment.unlockBinding <- function(){ - e <- new.env() - e$a <- 1:10 - e$b <- letters - lockBinding( "b", e ) - runit_unlockbinding(e, "b") - checkTrue( !bindingIsLocked("b", e ), msg = "Environment::lockBinding()" ) - - can.demangle <- Rcpp:::capabilities()[["demangling"]] - if( can.demangle ){ - checkTrue( - tryCatch( { runit_unlockbinding(e, "xx" ) ; FALSE}, "Rcpp::no_such_binding" = function(e) TRUE ), - msg = "Environment::unlockBinding(no binding) -> exception)" ) - } else { - checkTrue( - tryCatch( { runit_unlockbinding(e, "xx" ) ; FALSE}, error = function(e) TRUE ), - msg = "Environment::unlockBinding(no binding) -> exception)" ) - } - } - - test.environment.global.env <- function(){ - checkIdentical( runit_globenv(), globalenv(), msg = "Environment::global_env" ) - } - - test.environment.empty.env <- function(){ - checkIdentical( runit_emptyenv(), emptyenv(), msg = "Environment::empty_env" ) - } - - test.environment.base.env <- function(){ - checkIdentical( runit_baseenv(), baseenv(), msg = "Environment::base_env" ) - } - - test.environment.namespace.env <- function(){ - checkIdentical( runit_namespace("Rcpp"), asNamespace("Rcpp"), msg = "Environment::base_namespace" ) - - can.demangle <- Rcpp:::capabilities()[["demangling"]] - if( can.demangle ){ - checkTrue( - tryCatch( { runit_namespace("----" ) ; FALSE}, "Rcpp::no_such_namespace" = function(e) TRUE ), - msg = "Environment::namespace_env(no namespace) -> exception)" ) - } else { - checkTrue( - tryCatch( { runit_namespace("----" ) ; FALSE}, error = function(e) TRUE ), - msg = "Environment::namespace_env(no namespace) -> exception)" ) - } - } - - test.environment.constructor.SEXP <- function(){ - checkIdentical( runit_env_SEXP( globalenv() ), globalenv(), msg = "Environment( environment ) - 1" ) - checkIdentical( runit_env_SEXP( baseenv() ), baseenv(), msg = "Environment( environment ) - 2" ) - checkIdentical( runit_env_SEXP( asNamespace("Rcpp") ), asNamespace("Rcpp"), msg = "Environment( environment ) - 3" ) - - checkIdentical( runit_env_SEXP( ".GlobalEnv" ), globalenv(), msg = "Environment( character ) - 1" ) - checkIdentical( runit_env_SEXP( "package:base" ), baseenv(), msg = "Environment( character ) - 2" ) - checkIdentical( runit_env_SEXP( "package:Rcpp" ), as.environment("package:Rcpp") , msg = 'Environment( "package:Rcpp") ' ) - - checkIdentical( runit_env_SEXP(1L), globalenv(), msg = "Environment( SEXP{integer} )" ) - } - - test.environment.constructor.stdstring <- function(){ - checkIdentical( runit_env_string( ".GlobalEnv" ), globalenv(), msg = "Environment( std::string ) - 1" ) - checkIdentical( runit_env_string( "package:base" ), baseenv(), msg = "Environment( std::string ) - 2" ) - checkIdentical( runit_env_string( "package:Rcpp" ), as.environment("package:Rcpp") , - msg = 'Environment( std::string ) - 3' ) - - } - - test.environment.constructor.int <- function(){ - for( i in 1:length(search())){ - checkIdentical( runit_env_int(i), as.environment(i), msg = sprintf("Environment(int) - %d", i) ) - } - } - - test.environment.remove <- function(){ - e <- new.env( ) - e$a <- 1 - e$b <- 2 - checkTrue( runit_remove( e, "a" ), msg = "Environment::remove" ) - checkEquals( ls(envir=e), "b", msg = "check that the element was removed" ) - checkException( runit_remove(e, "xx"), msg = "Environment::remove no such binding" ) - lockBinding( "b", e ) - checkException( runit_remove(e, "b"), msg = "Environment::remove binding is locked" ) - checkEquals( ls(envir=e), "b", msg = "check that the element was not removed" ) - - } - - test.environment.parent <- function(){ - e <- new.env( parent = emptyenv() ) - f <- new.env( parent = e ) - checkEquals( runit_parent(f), e, msg = "Environment::parent" ) - checkEquals( runit_parent(e), emptyenv() , msg = "Environment::parent" ) - } - - test.environment.square <- function(){ - env <- new.env( ) - env[["x"]] <- 10L - checkEquals( runit_square(env), list( 10L, 2L, "foo") ) - - } - - test.environment.Rcpp <- function(){ - checkEquals( runit_Rcpp(), asNamespace("Rcpp") , msg = "cached Rcpp namespace" ) - } - - #test.environment.child <- function(){ - # checkEquals( parent.env(runit_child()), globalenv(), msg = "child environment" ) - #} - - test.environment.new_env <- function() { - env <- new.env() - checkIdentical(parent.env(runit_new_env_default()), emptyenv(), msg = "new environment with default parent") - checkIdentical(parent.env(runit_new_env_parent(env)), env, msg = "new environment with specified parent") - } - -} diff --git a/inst/unitTests/runit.exceptions.R b/inst/unitTests/runit.exceptions.R deleted file mode 100644 index f472f3e89..000000000 --- a/inst/unitTests/runit.exceptions.R +++ /dev/null @@ -1,123 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# 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 . -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - .setUp <- Rcpp:::unitTestSetup("exceptions.cpp") - -test.stdException <- function() { - - # Code works normally without an exception - checkIdentical(takeLog(1L), log(1L)) - - # C++ exceptions are converted to R conditions - condition <- tryCatch(takeLog(-1L), error = identity) - - checkIdentical(condition$message, "Inadmissible value") - checkIdentical(class(condition), c("std::range_error", "C++Error", "error", "condition")) - - # C++ stack only available for Rcpp::exceptions - checkTrue(is.null(condition$cppstack)) - - checkIdentical(condition$call, quote(takeLog(-1L))) -} - - -test.rcppException <- function() { - - # Code works normally without an exception - checkIdentical(takeLog(1L), log(1L)) - - # C++ exceptions are converted to R conditions - condition <- tryCatch(takeLogRcpp(-1L), error = identity) - - checkIdentical(condition$message, "Inadmissible value") - checkIdentical(class(condition), c("Rcpp::exception", "C++Error", "error", "condition")) - - checkTrue(!is.null(condition$cppstack)) - - checkIdentical(class(condition$cppstack), "Rcpp_stack_trace") - - checkEquals(condition$call, quote(takeLogRcpp(-1L))) -} - -test.rcppStop <- function() { - - # Code works normally without an exception - checkIdentical(takeLog(1L), log(1L)) - - # C++ exceptions are converted to R conditions - condition <- tryCatch(takeLogStop(-1L), error = identity) - - checkIdentical(condition$message, "Inadmissible value") - checkIdentical(class(condition), c("Rcpp::exception", "C++Error", "error", "condition")) - - checkTrue(!is.null(condition$cppstack)) - - checkIdentical(class(condition$cppstack), "Rcpp_stack_trace") - - checkEquals(condition$call, quote(takeLogStop(-1L))) -} - -test.rcppExceptionLocation <- function() { - - # Code works normally without an exception - checkIdentical(takeLog(1L), log(1L)) - - # C++ exceptions are converted to R conditions - condition <- tryCatch(takeLogRcppLocation(-1L), error = identity) - - checkIdentical(condition$message, "Inadmissible value") - checkIdentical(class(condition), c("Rcpp::exception", "C++Error", "error", "condition")) - - checkTrue(!is.null(condition$cppstack)) - checkIdentical(class(condition$cppstack), "Rcpp_stack_trace") - - checkIdentical(condition$cppstack$file, "exceptions.cpp") - checkIdentical(condition$cppstack$line, 44L) - - checkEquals(condition$call, quote(takeLogRcppLocation(-1L))) -} - -test.rcppExceptionLocation <- function() { - - # Nested exceptions work the same way - normal <- tryCatch(takeLogRcppLocation(-1L), error = identity) - f1 <- function(x) takeLogNested(x) - - nested <- tryCatch(f1(-1), error = identity) - - # Message the same - checkIdentical(normal$message, nested$message) - - checkEquals(nested$call, quote(takeLogNested(x))) -} - -test.rcppExceptionNoCall <- function() { - - # Can throw exceptions that don't include a call stack - e <- tryCatch(noCall(), error = identity) - - checkIdentical(e$message, "Testing") - checkIdentical(e$call, NULL) - checkIdentical(e$cppstack, NULL) - checkIdentical(class(e), c("Rcpp::exception", "C++Error", "error", "condition")) -} -} diff --git a/inst/unitTests/runit.exposeClass.R b/inst/unitTests/runit.exposeClass.R deleted file mode 100644 index 3bc598a55..000000000 --- a/inst/unitTests/runit.exposeClass.R +++ /dev/null @@ -1,103 +0,0 @@ -# Copyright (C) 2013 - 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - test.exposeClass <- function(){ - - tempdir <- tempdir() - ## foo has already been loaded in test.Rcpp.package.skeleton.R, - ## so named differently here to avoid namespace conflicts - pkg_name <- "fooModule" - path <- tempdir - pkg_path <- file.path(path, pkg_name) - R_path <- file.path(pkg_path, "R") - src_path <- file.path(pkg_path, "src") - foo_header <- " -#ifndef foo_h -#define foo_h 1 -// class to set/get double -class foo { - public: - double x; - double get_x() {return x;} - void set_x(double _x) {x = _x; return;} - foo(double _x) {set_x(_x);} -}; -#endif -" - - ## create package - Rcpp.package.skeleton(pkg_name, path=path, environment = environment(), - example_code = FALSE, module = TRUE) - on.exit(unlink(pkg_path, recursive=TRUE)) - file.remove(list.files(c(src_path, R_path), full.names = TRUE)) - cat(foo_header, file = file.path(src_path, "foo.h")) - - ## check that result of exposeClass compiles and runs properly - exposeClass(class = "fooR", - constructors = list("double"), - fields = "x", - methods = c("get_x", "set_x"), - header = '#include "foo.h"', - CppClass = "foo", - rename = c(y = "x", get_y = "get_x", set_y = "set_x"), - file = file.path(src_path, "fooModule.cpp"), - Rfile = file.path(R_path, "fooClass.R")) - compileAttributes(pkg_path) - invisible(sapply( list.files( file.path(pkg_path, "man"), full.names=TRUE), unlink )) - - ## check build - owd <- getwd() - 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") - checkTrue( file.exists(gz_name), "can successfully R CMD build the pkg") - - ## check install + require - dir.create("templib") - install.packages(gz_name, file.path(path, "templib"), repos=NULL, type="source") - on.exit( unlink( file.path(path, gz_name) ), add=TRUE) - status <- require(pkg_name, file.path(path, "templib"), character.only=TRUE) - on.exit( unlink( file.path(path, "templib"), recursive=TRUE), add=TRUE ) - checkTrue(status, "can successfully require the pkg") - - ## check object creation - bar <- fooR(0) - env <- environment() - checkTrue( exists("bar", envir = env, inherits = FALSE), - "module object successfully instantiated" ) - gs <- replicate(n = 10, { - y <- rnorm(1) - bar$set_y(y) - bar$get_y() - y - }) - checkTrue( all(gs == 0), "renamed methods function as expected" ) - gs <- replicate(n = 10, { - y <- rnorm(1) - bar$set_y(y) - bar$y - y - }) - checkTrue( all(gs == 0), "renamed direct field functions as expected" ) - - } - -} diff --git a/inst/unitTests/runit.interface.R b/inst/unitTests/runit.interface.R deleted file mode 100644 index 51d5da4b9..000000000 --- a/inst/unitTests/runit.interface.R +++ /dev/null @@ -1,100 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2018 RStudio -# -# 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 . -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - build_package <- function(name, lib_path, tempdir = getwd(), - config = character()) { - file.copy(system.file("unitTests", name, package = "Rcpp"), - getwd(), - recursive = TRUE) - - src_path <- file.path(tempdir, name) - Rcpp::compileAttributes(src_path) - writeLines(config, file.path(src_path, "src", "config.h")) - - install.packages( - src_path, - lib_path, - repos = NULL, - type = "source", - INSTALL_opts = "--install-tests" - ) - } - - test.interface.unwind <- function() { - exporter_name <- "testRcppInterfaceExporter" - user_name <- "testRcppInterfaceUser" - - tempdir <- tempfile() - dir.create(tempdir) - old_wd <- setwd(tempdir) - on.exit({ - setwd(old_wd) - unlink(tempdir, recursive = TRUE) - }) - - lib_path <- file.path(tempdir, "templib") - dir.create(lib_path) - - old_lib_paths <- .libPaths() - on.exit(.libPaths(old_lib_paths), add = TRUE) - .libPaths(c(lib_path, old_lib_paths)) - - # Without this testInstalledPackage() won't find installed - # packages even though we've passed `lib.loc` - old_libs_envvar <- Sys.getenv("R_LIBS") - on.exit(Sys.setenv(R_LIBS = old_libs_envvar), add = TRUE) - - sys_sep <- if (.Platform$OS.type == "windows") ";" else ":" - Sys.setenv(R_LIBS = paste(c(lib_path, old_lib_paths), collapse = sys_sep)) - - cfg <- "#define RCPP_USE_UNWIND_PROTECT" - build_package(exporter_name, lib_path, config = cfg) - build_package(user_name, lib_path, config = cfg) - - result <- tools::testInstalledPackage(user_name, lib.loc = lib_path, types = "test") - - # Be verbose if tests were not successful - if (result) { - log <- file.path(paste0(user_name, "-tests"), "tests.Rout.fail") - cat(">> PROTECTED tests.Rout.fail", readLines(log), sep = "\n", file = stderr()) - } - - checkEquals(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 = character()) - - result <- tools::testInstalledPackage(user_name, lib.loc = lib_path, types = "test") - - if (result) { - log <- file.path(paste0(user_name, "-tests"), "tests.Rout.fail") - cat(">> UNPROTECTED tests.Rout.fail", readLines(log), sep = "\n", file = stderr()) - } - - checkEquals(result, 0L) - } - -} diff --git a/inst/unitTests/runit.misc.R b/inst/unitTests/runit.misc.R deleted file mode 100644 index ccabe0ea9..000000000 --- a/inst/unitTests/runit.misc.R +++ /dev/null @@ -1,217 +0,0 @@ -#!/usr/bin/env r -# -# Copyright (C) 2010 - 2017 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("misc.cpp") - - test.Symbol <- function(){ - res <- symbol_() - checkTrue( res[1L], msg = "Symbol creation - SYMSXP " ) - checkTrue( res[2L], msg = "Symbol creation - CHARSXP " ) - checkTrue( res[3L], msg = "Symbol creation - STRSXP " ) - checkTrue( res[4L], msg = "Symbol creation - std::string " ) - } - - test.Symbol.notcompatible <- function(){ - checkException( symbol_ctor(symbol_ctor), msg = "Symbol not compatible with function" ) - checkException( symbol_ctor(asNamespace("Rcpp")), msg = "Symbol not compatible with environment" ) - checkException( symbol_ctor(1:10), msg = "Symbol not compatible with integer" ) - checkException( symbol_ctor(TRUE), msg = "Symbol not compatible with logical" ) - checkException( symbol_ctor(1.3), msg = "Symbol not compatible with numeric" ) - checkException( symbol_ctor(as.raw(1) ), msg = "Symbol not compatible with raw" ) - } - - - test.Argument <- function(){ - checkEquals( Argument_(), list( x = 2L, y = 3L ) , msg = "Argument") - } - - test.Dimension.const <- function(){ - checkEquals( Dimension_const( c(2L, 2L)) , 2L, msg = "testing const operator[]" ) - } - - test.evaluator.error <- function(){ - checkException( evaluator_error(), msg = "Rcpp_eval( stop() )" ) - } - - test.evaluator.ok <- function(){ - checkEquals( sort(evaluator_ok(1:10)), 1:10, msg = "Rcpp_eval running fine" ) - } - - test.exceptions <- function(){ - can.demangle <- Rcpp:::capabilities()[["demangling"]] - - e <- tryCatch( exceptions_(), "C++Error" = function(e) e ) - checkTrue( "C++Error" %in% class(e), msg = "exception class C++Error" ) - - if( can.demangle ){ - checkTrue( "std::range_error" %in% class(e), msg = "exception class std::range_error" ) - } - checkEquals( e$message, "boom", msg = "exception message" ) - - if( can.demangle ){ - # same with direct handler - e <- tryCatch( exceptions_(), "std::range_error" = function(e) e ) - checkTrue( "C++Error" %in% class(e), msg = "(direct handler) exception class C++Error" ) - checkTrue( "std::range_error" %in% class(e), msg = "(direct handler) exception class std::range_error" ) - checkEquals( e$message, "boom", msg = "(direct handler) exception message" ) - } - f <- function(){ - try( exceptions_(), silent = TRUE) - "hello world" - } - checkEquals( f(), "hello world", msg = "life continues after an exception" ) - - } - - test.has.iterator <- function(){ - - has_it <- has_iterator_() - checkTrue( has_it[1L] , msg = "has_iterator< std::vector >" ) - checkTrue( has_it[2L] , msg = "has_iterator< std::ist >" ) - checkTrue( has_it[3L] , msg = "has_iterator< std::deque >" ) - checkTrue( has_it[4L] , msg = "has_iterator< std::set >" ) - checkTrue( has_it[5L] , msg = "has_iterator< std::map >" ) - - checkTrue( ! has_it[6L] , msg = "has_iterator< std::pair >" ) - checkTrue( ! has_it[7L] , msg = "Rcpp::Symbol" ) - - } - - test.AreMacrosDefined <- function(){ - checkTrue( Rcpp:::areMacrosDefined( "__cplusplus" ) ) - } - - test.rcout <- function(){ - ## define test string that is written to two files - teststr <- "First line.\nSecond line." - - rcppfile <- tempfile() - rfile <- tempfile() - - ## write to test_rcpp.txt from Rcpp - test_rcout(rcppfile, teststr ) - - ## write to test_r.txt from R - cat( teststr, file=rfile, sep='\n' ) - - ## compare whether the two files have the same data - checkEquals( readLines(rcppfile), readLines(rfile), msg="Rcout output") - } - - test.rcout.complex <- function(){ - - rcppfile <- tempfile() - rfile <- tempfile() - - z <- complex(real=sample(1:10, 1), imaginary=sample(1:10, 1)) - - ## write to test_rcpp.txt from Rcpp - test_rcout_rcomplex(rcppfile, z ) - - ## write to test_r.txt from R - cat( z, file=rfile, sep='\n' ) - - ## compare whether the two files have the same data - checkEquals( readLines(rcppfile), readLines(rfile), msg="Rcout Rcomplex") - } - - test.na_proxy <- function(){ - checkEquals( - na_proxy(), - rep(c(TRUE,TRUE,TRUE,FALSE,FALSE,FALSE,FALSE,FALSE,FALSE) , 2), - msg = "Na_Proxy NA == handling" - ) - } - - test.StretchyList <- function(){ - checkEquals( - stretchy_list(), - pairlist( "foo", 1L, 3.2 ) - ) - } - - test.named_StretchyList <- function(){ - checkEquals( - named_stretchy_list(), - pairlist( a = "foo", b = 1L, c = 3.2 ) - ) - } - - test.stop.variadic <- function(){ - m <- tryCatch( test_stop_variadic(), error = function(e){ - conditionMessage(e) - }) - checkEquals( m, "foo 3" ) - } - - test.NullableForNull <- function() { - M <- matrix(1:4, 2, 2) - checkTrue( testNullableForNull(NULL) ) - checkTrue( ! testNullableForNull(M) ) - } - - test.NullableForNotNull <- function() { - M <- matrix(1:4, 2, 2) - checkTrue( ! testNullableForNotNull(NULL) ) - checkTrue( testNullableForNotNull(M) ) - } - - test.NullableAccessOperator <- function() { - M <- matrix(1:4, 2, 2) - checkEquals( testNullableOperator(M), M ) - } - - test.NullableAccessGet <- function() { - M <- matrix(1:4, 2, 2) - checkEquals( testNullableGet(M), M ) - } - - test.NullableAccessAs <- function() { - M <- matrix(1:4, 2, 2) - checkEquals( testNullableAs(M), M ) - } - - test.NullableAccessClone <- function() { - M <- matrix(1:4, 2, 2) - checkEquals( testNullableClone(M), M ) - } - - test.NullableIsUsableTrue <- function() { - M <- matrix(1:4, 2, 2) - checkEquals( testNullableIsUsable(M), M) - } - - test.NullableIsUsableFalse <- function() { - checkTrue(is.null(testNullableIsUsable(NULL))) - } - - test.NullableString <- function() { - checkEquals(testNullableString(), "") - checkEquals(testNullableString("blah"), "blah") - } - - test.bib <- function() { - checkTrue(nchar(Rcpp:::bib()) > 0, msg="bib file") - } - -} diff --git a/inst/unitTests/runit.modref.R b/inst/unitTests/runit.modref.R deleted file mode 100644 index 03f15033f..000000000 --- a/inst/unitTests/runit.modref.R +++ /dev/null @@ -1,45 +0,0 @@ -#!/usr/bin/env r -# -# Copyright (C) 2010 - 2015 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("modref.cpp") - - test.modRef <- function() { - ww <- new(ModRefWorld) - wg <- ModRefWorld$new() - - checkEquals(ww$greet(), wg$greet()) - wgg <- wg$greet() - - ww$set("Other") - - ## test independence of ww, wg - checkEquals(ww$greet(), "Other") - checkEquals(wg$greet(), wgg) - - ModRefWorld$methods(twice = function() paste(greet(), greet())) - - checkEquals(ww$twice(), paste(ww$greet(), ww$greet())) - - } - -} diff --git a/inst/unitTests/runit.na.R b/inst/unitTests/runit.na.R deleted file mode 100644 index 5ae5bd679..000000000 --- a/inst/unitTests/runit.na.R +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2014 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - -.setUp <- Rcpp:::unitTestSetup("na.cpp") - -test.na <- function() { - checkIdentical( R_IsNA_(NA_real_), Rcpp_IsNA(NA_real_) ) - checkIdentical( R_IsNA_(NA_real_+1), Rcpp_IsNA(NA_real_+1) ) - checkIdentical( R_IsNA_(NA_real_+NaN), Rcpp_IsNA(NA_real_+NaN) ) - checkIdentical( R_IsNA_(NaN+NA_real_), Rcpp_IsNA(NaN+NA_real_) ) - checkIdentical( R_IsNaN_(NA_real_), Rcpp_IsNaN(NA_real_) ) - checkIdentical( R_IsNaN_(NaN), Rcpp_IsNaN(NaN) ) - checkIdentical( R_IsNaN_(NaN+1), Rcpp_IsNaN(NaN+1) ) -} - -} diff --git a/inst/unitTests/runit.quickanddirty.R b/inst/unitTests/runit.quickanddirty.R deleted file mode 100644 index c29e16138..000000000 --- a/inst/unitTests/runit.quickanddirty.R +++ /dev/null @@ -1,60 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; ess-indent-level: 4; tab-width: 4; indent-tabs-mode: nil; -* -# -# Copyright (C) 2012 - 2016 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (FALSE && .runThisTest) { - - #.setUp <- Rcpp:::unitTestSetup("rmath.cpp") - sourceCpp("cpp/rmath.cpp") - - test.rmath.norm <- function() { - x <- 0.25 - a <- 1.25 - b <- 2.50 - checkEquals(runit_dnorm(x, a, b), - c(dnorm(x, a, b, log=FALSE), dnorm(x, a, b, log=TRUE)), - msg = " rmath.dnorm") - - checkEquals(runit_pnorm(x, a, b), - c(pnorm(x, a, b, lower=TRUE, log=FALSE), pnorm(log(x), a, b, lower=TRUE, log=TRUE), - pnorm(x, a, b, lower=FALSE, log=FALSE), pnorm(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pnorm") - - checkEquals(runit_qnorm(x, a, b), - c(qnorm(x, a, b, lower=TRUE, log=FALSE), qnorm(log(x), a, b, lower=TRUE, log=TRUE), - qnorm(x, a, b, lower=FALSE, log=FALSE), qnorm(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qnorm") - - set.seed(333) - rcpp_result <- runit_rnorm(a, b) - set.seed(333) - rcpp_result_sugar <- runit_rnorm_sugar(a, b) - set.seed(333) - r_result <- rnorm(5, a, b) - - checkEquals(rcpp_result, r_result, msg = " rmath.rnorm") - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rnorm.sugar") - } - -} - - - diff --git a/inst/unitTests/runit.rmath.R b/inst/unitTests/runit.rmath.R deleted file mode 100644 index ab87e7965..000000000 --- a/inst/unitTests/runit.rmath.R +++ /dev/null @@ -1,654 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; ess-indent-level: 4; tab-width: 4; indent-tabs-mode: nil; -* -# -# Copyright (C) 2012 - 2016 Dirk Eddelbuettel and Romain Francois -# Copyright (C) 2016 Dirk Eddelbuettel 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("rmath.cpp") - - test.rmath.norm <- function() { - x <- 0.25 - a <- 1.25 - b <- 2.50 - checkEquals(runit_dnorm(x, a, b), - c(dnorm(x, a, b, log=FALSE), dnorm(x, a, b, log=TRUE)), - msg = " rmath.dnorm") - - checkEquals(runit_pnorm(x, a, b), - c(pnorm(x, a, b, lower=TRUE, log=FALSE), pnorm(log(x), a, b, lower=TRUE, log=TRUE), - pnorm(x, a, b, lower=FALSE, log=FALSE), pnorm(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pnorm") - - checkEquals(runit_qnorm(x, a, b), - c(qnorm(x, a, b, lower=TRUE, log=FALSE), qnorm(log(x), a, b, lower=TRUE, log=TRUE), - qnorm(x, a, b, lower=FALSE, log=FALSE), qnorm(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qnorm") - - set.seed(333) - r_result <- rnorm(5, a, b) - set.seed(333) - rcpp_result <- runit_rnorm(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rnorm") - - set.seed(333) - rcpp_result_sugar <- runit_rnorm_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rnorm.sugar") - } - - test.rmath.unif <- function() { - x <- 0.25 - a <- 1.25 - b <- 2.50 - checkEquals(runit_dunif(x, a, b), - c(dunif(x, a, b, log=FALSE), dunif(x, a, b, log=TRUE)), - msg = " rmath.dunif") - - checkEquals(runit_punif(x, a, b), - c(punif(x, a, b, lower=TRUE, log=FALSE), punif(log(x), a, b, lower=TRUE, log=TRUE), - punif(x, a, b, lower=FALSE, log=FALSE), punif(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.punif") - - checkEquals(runit_qunif(x, a, b), - c(qunif(x, a, b, lower=TRUE, log=FALSE), qunif(log(x), a, b, lower=TRUE, log=TRUE), - qunif(x, a, b, lower=FALSE, log=FALSE), qunif(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qunif") - - set.seed(333) - r_result <- runif(5, a, b) - set.seed(333) - rcpp_result <- runit_runif(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.runif") - - set.seed(333) - rcpp_result_sugar <- runit_runif_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.runif.sugar") - } - - test.rmath.gamma <- function() { - x <- 0.25 - a <- 1.0 - b <- 1.0 - checkEquals(runit_dgamma(x, a, b), - c(dgamma(x, a, b, log=FALSE), dgamma(x, a, b, log=TRUE)), - msg = " rmath.dgamma") - - checkEquals(runit_pgamma(x, a, b), - c(pgamma(x, a, b, lower=TRUE, log=FALSE), pgamma(log(x), a, b, lower=TRUE, log=TRUE), - pgamma(x, a, b, lower=FALSE, log=FALSE), pgamma(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pgamma") - - checkEquals(runit_qgamma(x, a, b), - c(qgamma(x, a, b, lower=TRUE, log=FALSE), qgamma(log(x), a, b, lower=TRUE, log=TRUE), - qgamma(x, a, b, lower=FALSE, log=FALSE), qgamma(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qgamma") - - set.seed(333) - r_result <- rgamma(5, a, b) - set.seed(333) - rcpp_result <- runit_rgamma(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rgamma") - - set.seed(333) - rcpp_result_sugar <- runit_rgamma_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rgamma.sugar") - } - - test.rmath.beta <- function() { - x <- 0.25 - a <- 0.8 - b <- 2.5 - checkEquals(runit_dbeta(x, a, b), - c(dbeta(x, a, b, log=FALSE), dbeta(x, a, b, log=TRUE)), - msg = " rmath.dbeta") - - checkEquals(runit_pbeta(x, a, b), - c(pbeta(x, a, b, lower=TRUE, log=FALSE), pbeta(log(x), a, b, lower=TRUE, log=TRUE), - pbeta(x, a, b, lower=FALSE, log=FALSE), pbeta(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pbeta") - - checkEquals(runit_qbeta(x, a, b), - c(qbeta(x, a, b, lower=TRUE, log=FALSE), qbeta(log(x), a, b, lower=TRUE, log=TRUE), - qbeta(x, a, b, lower=FALSE, log=FALSE), qbeta(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qbeta") - - set.seed(333) - r_result <- rbeta(5, a, b) - set.seed(333) - rcpp_result <- runit_rbeta(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rbeta") - - set.seed(333) - rcpp_result_sugar <- runit_rbeta(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rbeta.sugar") - - } - - - test.rmath.lnorm <- function() { - x <- 0.25 - a <- 0.8 - b <- 2.5 - checkEquals(runit_dlnorm(x, a, b), - c(dlnorm(x, a, b, log=FALSE), dlnorm(x, a, b, log=TRUE)), - msg = " rmath.dlnorm") - - checkEquals(runit_plnorm(x, a, b), - c(plnorm(x, a, b, lower=TRUE, log=FALSE), plnorm(log(x), a, b, lower=TRUE, log=TRUE), - plnorm(x, a, b, lower=FALSE, log=FALSE), plnorm(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.plnorm") - - checkEquals(runit_qlnorm(x, a, b), - c(qlnorm(x, a, b, lower=TRUE, log=FALSE), qlnorm(log(x), a, b, lower=TRUE, log=TRUE), - qlnorm(x, a, b, lower=FALSE, log=FALSE), qlnorm(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qlnorm") - - set.seed(333) - r_result <- rlnorm(5, a, b) - set.seed(333) - rcpp_result <- runit_rlnorm(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rlnorm") - - set.seed(333) - rcpp_result_sugar <- runit_rlnorm_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rlnorm.sugar") - } - - - test.rmath.chisq <- function() { - x <- 0.25 - a <- 0.8 - checkEquals(runit_dchisq(x, a), - c(dchisq(x, a, log=FALSE), dchisq(x, a, log=TRUE)), - msg = " rmath.dchisq") - - checkEquals(runit_pchisq(x, a), - c(pchisq(x, a, lower=TRUE, log=FALSE), pchisq(log(x), a, lower=TRUE, log=TRUE), - pchisq(x, a, lower=FALSE, log=FALSE), pchisq(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.pchisq") - - checkEquals(runit_qchisq(x, a), - c(qchisq(x, a, lower=TRUE, log=FALSE), qchisq(log(x), a, lower=TRUE, log=TRUE), - qchisq(x, a, lower=FALSE, log=FALSE), qchisq(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.qchisq") - - set.seed(333) - r_result <- rchisq(5, a) - set.seed(333) - rcpp_result <- runit_rchisq(a) - checkEquals(rcpp_result, r_result, msg = " rmath.rchisq") - - set.seed(333) - rcpp_result_sugar <- runit_rchisq_sugar(a) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rchisq.sugar") - } - - - test.rmath.nchisq <- function() { - x <- 0.25 - a <- 0.8 - b <- 2.5 - checkEquals(runit_dnchisq(x, a, b), - c(dchisq(x, a, b, log=FALSE), dchisq(x, a, b, log=TRUE)), - msg = " rmath.dnchisq") - - checkEquals(runit_pnchisq(x, a, b), - c(pchisq(x, a, b, lower=TRUE, log=FALSE), pchisq(log(x), a, b, lower=TRUE, log=TRUE), - pchisq(x, a, b, lower=FALSE, log=FALSE), pchisq(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pnchisq") - - checkEquals(runit_qnchisq(x, a, b), - c(qchisq(x, a, b, lower=TRUE, log=FALSE), qchisq(log(x), a, b, lower=TRUE, log=TRUE), - qchisq(x, a, b, lower=FALSE, log=FALSE), qchisq(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qnchisq") - } - - - test.rmath.f <- function() { - x <- 0.25 - a <- 0.8 - b <- 2.5 - checkEquals(runit_df(x, a, b), - c(df(x, a, b, log=FALSE), df(x, a, b, log=TRUE)), - msg = " rmath.df") - - checkEquals(runit_pf(x, a, b), - c(pf(x, a, b, lower=TRUE, log=FALSE), pf(log(x), a, b, lower=TRUE, log=TRUE), - pf(x, a, b, lower=FALSE, log=FALSE), pf(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pf") - - checkEquals(runit_qf(x, a, b), - c(qf(x, a, b, lower=TRUE, log=FALSE), qf(log(x), a, b, lower=TRUE, log=TRUE), - qf(x, a, b, lower=FALSE, log=FALSE), qf(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qf") - - set.seed(333) - r_result <- rf(5, a, b) - set.seed(333) - rcpp_result <- runit_rf(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rf") - - set.seed(333) - rcpp_result_sugar <- runit_rf_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rf.sugar") - } - - - test.rmath.t <- function() { - x <- 0.25 - a <- 0.8 - checkEquals(runit_dt(x, a), - c(dt(x, a, log=FALSE), dt(x, a, log=TRUE)), - msg = " rmath.dt") - - checkEquals(runit_pt(x, a), - c(pt(x, a, lower=TRUE, log=FALSE), pt(log(x), a, lower=TRUE, log=TRUE), - pt(x, a, lower=FALSE, log=FALSE), pt(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.pt") - - checkEquals(runit_qt(x, a), - c(qt(x, a, lower=TRUE, log=FALSE), qt(log(x), a, lower=TRUE, log=TRUE), - qt(x, a, lower=FALSE, log=FALSE), qt(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.qt") - - set.seed(333) - r_result <- rt(5, a) - set.seed(333) - rcpp_result <- runit_rt(a) - checkEquals(rcpp_result, r_result, msg = " rmath.rt") - - set.seed(333) - rcpp_result_sugar <- runit_rt_sugar(a) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rt.sugar") - } - - - test.rmath.binom <- function() { - x <- 5 - a <- 10 - b <- 0.5 - checkEquals(runit_dbinom(x, a, b), - c(dbinom(x, a, b, log=FALSE), dbinom(x, a, b, log=TRUE)), - msg = " rmath.dbinom") - - checkEquals(runit_pbinom(x, a, b), - c(pbinom(x, a, b, lower=TRUE, log=FALSE), pbinom(log(x), a, b, lower=TRUE, log=TRUE), - pbinom(x, a, b, lower=FALSE, log=FALSE), pbinom(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pbinom") - - x <- x/a - checkEquals(runit_qbinom(x, a, b), - c(qbinom(x, a, b, lower=TRUE, log=FALSE), qbinom(log(x), a, b, lower=TRUE, log=TRUE), - qbinom(x, a, b, lower=FALSE, log=FALSE), qbinom(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qbinom") - - set.seed(333) - r_result <- rbinom(5, a, b) - set.seed(333) - rcpp_result <- runit_rbinom(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rbinom") - - set.seed(333) - rcpp_result_sugar <- runit_rbinom_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rbinom.sugar") - } - - - test.rmath.cauchy <- function() { - x <- 0.25 - a <- 0.8 - b <- 2.5 - checkEquals(runit_dcauchy(x, a, b), - c(dcauchy(x, a, b, log=FALSE), dcauchy(x, a, b, log=TRUE)), - msg = " rmath.dcauchy") - - checkEquals(runit_pcauchy(x, a, b), - c(pcauchy(x, a, b, lower=TRUE, log=FALSE), pcauchy(log(x), a, b, lower=TRUE, log=TRUE), - pcauchy(x, a, b, lower=FALSE, log=FALSE), pcauchy(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pcauchy") - - checkEquals(runit_qcauchy(x, a, b), - c(qcauchy(x, a, b, lower=TRUE, log=FALSE), qcauchy(log(x), a, b, lower=TRUE, log=TRUE), - qcauchy(x, a, b, lower=FALSE, log=FALSE), qcauchy(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qcauchy") - - set.seed(333) - r_result <- rcauchy(5, a, b) - set.seed(333) - rcpp_result <- runit_rcauchy(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rcauchy") - - set.seed(333) - rcpp_result_sugar <- runit_rcauchy_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rcauchy.sugar") - } - - - test.rmath.exp <- function() { - x <- 0.25 - a <- 1.0 - checkEquals(runit_dexp(x, a), - c(dexp(x, a, log=FALSE), dexp(x, a, log=TRUE)), - msg = " rmath.dexp") - - checkEquals(runit_pexp(x, a), - c(pexp(x, a, lower=TRUE, log=FALSE), pexp(log(x), a, lower=TRUE, log=TRUE), - pexp(x, a, lower=FALSE, log=FALSE), pexp(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.pexp") - - checkEquals(runit_qexp(x, a), - c(qexp(x, a, lower=TRUE, log=FALSE), qexp(log(x), a, lower=TRUE, log=TRUE), - qexp(x, a, lower=FALSE, log=FALSE), qexp(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.qexp") - - set.seed(333) - r_result <- rexp(5, a) - set.seed(333) - rcpp_result <- runit_rexp(a) - checkEquals(rcpp_result, r_result, msg = " rmath.rexp") - - set.seed(333) - rcpp_result_sugar <- runit_rexp_sugar(a) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rexp.sugar") - } - - - test.rmath.geom <- function() { - x <- 1 - a <- 0.75 - checkEquals(runit_dgeom(x, a), - c(dgeom(x, a, log=FALSE), dgeom(x, a, log=TRUE)), - msg = " rmath.dgeom") - - checkEquals(runit_pgeom(x, a), - c(pgeom(x, a, lower=TRUE, log=FALSE), pgeom(log(x), a, lower=TRUE, log=TRUE), - pgeom(x, a, lower=FALSE, log=FALSE), pgeom(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.pgeom") - - checkEquals(runit_qgeom(x, a), - c(qgeom(x, a, lower=TRUE, log=FALSE), qgeom(log(x), a, lower=TRUE, log=TRUE), - qgeom(x, a, lower=FALSE, log=FALSE), qgeom(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.qgeom") - - set.seed(333) - r_result <- rgeom(5, a) - set.seed(333) - rcpp_result <- runit_rgeom(a) - checkEquals(rcpp_result, r_result, msg = " rmath.rgeom") - - set.seed(333) - rcpp_result_sugar <- runit_rgeom_sugar(a) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rgeom.sugar") - } - - test.rmath.hyper <- function() { - x <- 5 - a <- 10 - b <- 7 - c <- 8 - checkEquals(runit_dhyper(x, a, b, c), - c(dhyper(x, a, b, c, log=FALSE), dhyper(x, a, b, c, log=TRUE)), - msg = " rmath.dhyper") - - checkEquals(runit_phyper(x, a, b, c), - c(phyper(x, a, b, c, lower=TRUE, log=FALSE), phyper(log(x), a, b, c, lower=TRUE, log=TRUE), - phyper(x, a, b, c, lower=FALSE, log=FALSE), phyper(log(x), a, b, c, lower=FALSE, log=TRUE)), - msg = " rmath.phyper") - - x <- x/a - checkEquals(runit_qhyper(x, a, b, c), - c(qhyper(x, a, b, c, lower=TRUE, log=FALSE), qhyper(log(x), a, b, c, lower=TRUE, log=TRUE), - qhyper(x, a, b, c, lower=FALSE, log=FALSE), qhyper(log(x), a, b, c, lower=FALSE, log=TRUE)), - msg = " rmath.qhyper") - - set.seed(333) - r_result <- rhyper(5, a, b, c) - set.seed(333) - rcpp_result <- runit_rhyper(a, b, c) - checkEquals(rcpp_result, r_result, msg = " rmath.rhyper") - - set.seed(333) - rcpp_result_sugar <- runit_rhyper_sugar(a, b, c) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rhyper.sugar") - } - - - test.rmath.nbinom <- function() { - x <- 2 - a <- 8 - b <- 0.25 - checkEquals(runit_dnbinom(x, a, b), - c(dnbinom(x, a, b, log=FALSE), dnbinom(x, a, b, log=TRUE)), - msg = " rmath.dnbinom") - - checkEquals(runit_pnbinom(x, a, b), - c(pnbinom(x, a, b, lower=TRUE, log=FALSE), pnbinom(log(x), a, b, lower=TRUE, log=TRUE), - pnbinom(x, a, b, lower=FALSE, log=FALSE), pnbinom(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pnbinom") - - x <- x/a - checkEquals(runit_qnbinom(x, a, b), - c(qnbinom(x, a, b, lower=TRUE, log=FALSE), qnbinom(log(x), a, b, lower=TRUE, log=TRUE), - qnbinom(x, a, b, lower=FALSE, log=FALSE), qnbinom(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qnbinom") - - set.seed(333) - r_result <- rnbinom(5, a, b) - set.seed(333) - rcpp_result <- runit_rnbinom(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rnbinom") - - set.seed(333) - rcpp_result_sugar <- runit_rnbinom_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rnbinom.sugar") - } - - - test.rmath.pois <- function() { - x <- 2 - a <- 1.0 - checkEquals(runit_dpois(x, a), - c(dpois(x, a, log=FALSE), dpois(x, a, log=TRUE)), - msg = " rmath.dpois") - - checkEquals(runit_ppois(x, a), - c(ppois(x, a, lower=TRUE, log=FALSE), ppois(log(x), a, lower=TRUE, log=TRUE), - ppois(x, a, lower=FALSE, log=FALSE), ppois(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.ppois") - - x <- 1/x - checkEquals(runit_qpois(x, a), - c(qpois(x, a, lower=TRUE, log=FALSE), qpois(log(x), a, lower=TRUE, log=TRUE), - qpois(x, a, lower=FALSE, log=FALSE), qpois(log(x), a, lower=FALSE, log=TRUE)), - msg = " rmath.qpois") - - set.seed(333) - r_result <- rpois(5, a) - set.seed(333) - rcpp_result <- runit_rpois(a) - checkEquals(rcpp_result, r_result, msg = " rmath.rpois") - - set.seed(333) - rcpp_result_sugar <- runit_rpois_sugar(a) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rpois.sugar") - } - - - test.rmath.weibull <- function() { - x <- 2 - a <- 8 - b <- 0.25 - checkEquals(runit_dweibull(x, a, b), - c(dweibull(x, a, b, log=FALSE), dweibull(x, a, b, log=TRUE)), - msg = " rmath.dweibull") - - checkEquals(runit_pweibull(x, a, b), - c(pweibull(x, a, b, lower=TRUE, log=FALSE), pweibull(log(x), a, b, lower=TRUE, log=TRUE), - pweibull(x, a, b, lower=FALSE, log=FALSE), pweibull(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pweibull") - - x <- x/a - checkEquals(runit_qweibull(x, a, b), - c(qweibull(x, a, b, lower=TRUE, log=FALSE), qweibull(log(x), a, b, lower=TRUE, log=TRUE), - qweibull(x, a, b, lower=FALSE, log=FALSE), qweibull(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qweibull") - - set.seed(333) - r_result <- rweibull(5, a, b) - set.seed(333) - rcpp_result <- runit_rweibull(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rweibull") - - set.seed(333) - rcpp_result_sugar <- runit_rweibull_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rweibull.sugar") - } - - - test.rmath.logis <- function() { - x <- 2 - a <- 8 - b <- 0.25 - checkEquals(runit_dlogis(x, a, b), - c(dlogis(x, a, b, log=FALSE), dlogis(x, a, b, log=TRUE)), - msg = " rmath.dlogis") - - checkEquals(runit_plogis(x, a, b), - c(plogis(x, a, b, lower=TRUE, log=FALSE), plogis(log(x), a, b, lower=TRUE, log=TRUE), - plogis(x, a, b, lower=FALSE, log=FALSE), plogis(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.plogis") - - x <- x/a - checkEquals(runit_qlogis(x, a, b), - c(qlogis(x, a, b, lower=TRUE, log=FALSE), qlogis(log(x), a, b, lower=TRUE, log=TRUE), - qlogis(x, a, b, lower=FALSE, log=FALSE), qlogis(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qlogis") - - set.seed(333) - r_result <- rlogis(5, a, b) - set.seed(333) - rcpp_result <- runit_rlogis(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rlogis") - - set.seed(333) - rcpp_result_sugar <- runit_rlogis_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rlogis.sugar") - } - - - test.rmath.nbeta <- function() { - x <- 5 - a <- 10 - b <- 7 - c <- 8 - checkEquals(runit_dnbeta(x, a, b, c), - c(dbeta(x, a, b, c, log=FALSE), dbeta(x, a, b, c, log=TRUE)), - msg = " rmath.dnbeta") - - checkEquals(runit_pnbeta(x, a, b, c), - c(pbeta(x, a, b, c, lower=TRUE, log=FALSE), pbeta(log(x), a, b, c, lower=TRUE, log=TRUE), - pbeta(x, a, b, c, lower=FALSE, log=FALSE), pbeta(log(x), a, b, c, lower=FALSE, log=TRUE)), - msg = " rmath.pnbeta") - - x <- x/a - checkEquals(runit_qnbeta(x, a, b, c), - c(qbeta(x, a, b, c, lower=TRUE, log=FALSE), qbeta(log(x), a, b, c, lower=TRUE, log=TRUE), - qbeta(x, a, b, c, lower=FALSE, log=FALSE), qbeta(log(x), a, b, c, lower=FALSE, log=TRUE)), - msg = " rmath.qnbeta") - } - - - test.rmath.nf <- function() { - x <- 5 - a <- 10 - b <- 7 - c <- 8 - checkEquals(runit_dnf(x, a, b, c), - c(df(x, a, b, c, log=FALSE), df(x, a, b, c, log=TRUE)), - msg = " rmath.dnf") - - checkEquals(runit_pnf(x, a, b, c), - c(pf(x, a, b, c, lower=TRUE, log=FALSE), pf(log(x), a, b, c, lower=TRUE, log=TRUE), - pf(x, a, b, c, lower=FALSE, log=FALSE), pf(log(x), a, b, c, lower=FALSE, log=TRUE)), - msg = " rmath.pnf") - - x <- x/a - checkEquals(runit_qnf(x, a, b, c), - c(qf(x, a, b, c, lower=TRUE, log=FALSE), qf(log(x), a, b, c, lower=TRUE, log=TRUE), - qf(x, a, b, c, lower=FALSE, log=FALSE), qf(log(x), a, b, c, lower=FALSE, log=TRUE)), - msg = " rmath.qnf") - } - - test.rmath.nt <- function() { - x <- 5 - a <- 10 - b <- 7 - checkEquals(runit_dnt(x, a, b), - c(dt(x, a, b, log=FALSE), dt(x, a, b, log=TRUE)), - msg = " rmath.dnt") - - checkEquals(runit_pnt(x, a, b), - c(pt(x, a, b, lower=TRUE, log=FALSE), pt(log(x), a, b, lower=TRUE, log=TRUE), - pt(x, a, b, lower=FALSE, log=FALSE), pt(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pnt") - - x <- x/a - checkEquals(runit_qnt(x, a, b), - c(qt(x, a, b, lower=TRUE, log=FALSE), qt(log(x), a, b, lower=TRUE, log=TRUE), - qt(x, a, b, lower=FALSE, log=FALSE), qt(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qnt") - } - - test.rmath.wilcox <- function() { - x <- 2 - a <- 4 - b <- 6 - checkEquals(runit_dwilcox(x, a, b), - c(dwilcox(x, a, b, log=FALSE), dwilcox(x, a, b, log=TRUE)), - msg = " rmath.dwilcox") - - checkEquals(runit_pwilcox(x, a, b), - c(pwilcox(x, a, b, lower=TRUE, log=FALSE), pwilcox(log(x), a, b, lower=TRUE, log=TRUE), - pwilcox(x, a, b, lower=FALSE, log=FALSE), pwilcox(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.pwilcox") - - x <- x/a - checkEquals(runit_qwilcox(x, a, b), - c(qwilcox(x, a, b, lower=TRUE, log=FALSE), qwilcox(log(x), a, b, lower=TRUE, log=TRUE), - qwilcox(x, a, b, lower=FALSE, log=FALSE), qwilcox(log(x), a, b, lower=FALSE, log=TRUE)), - msg = " rmath.qwilcox") - - - set.seed(333) - r_result <- rwilcox(5, a, b) - set.seed(333) - rcpp_result <- runit_rwilcox(a, b) - checkEquals(rcpp_result, r_result, msg = " rmath.rwilcox") - - set.seed(333) - rcpp_result_sugar <- runit_rwilcox_sugar(a, b) - checkEquals(rcpp_result_sugar, r_result, msg = " rmath.rwilcox_sugar") - } - -} - - - diff --git a/inst/unitTests/runit.stack.R b/inst/unitTests/runit.stack.R deleted file mode 100644 index b4444a32c..000000000 --- a/inst/unitTests/runit.stack.R +++ /dev/null @@ -1,177 +0,0 @@ -#!/usr/bin/env r -# -# Copyright (C) 2010 - 2017 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("stack.cpp") - - # On old versions of R, Rcpp_fast_eval() falls back to Rcpp_eval() and - # leaks on longjumps - hasUnwind <- getRversion() >= "3.5.0" - checkUnwound <- if (hasUnwind) checkTrue else function(x) checkIdentical(x, NULL) - checkErrorMessage <- function(x, msg) { - if (!hasUnwind) { - msg <- paste0("Evaluation error: ", msg, ".") - } - checkIdentical(x$message, msg) - } - evalUnwind <- function(expr, indicator) { - testFastEval(expr, parent.frame(), indicator) - } - - # Wrap the unwind indicator in an environment because mutating - # vectors passed by argument can corrupt the R session in - # byte-compiled code. - newIndicator <- function() { - env <- new.env() - env$unwound <- NULL - env - } - - # Stack is always unwound on errors and interrupts - test.stackUnwindsOnErrors <- function() { - indicator <- newIndicator() - out <- tryCatch(evalUnwind(quote(stop("err")), indicator), error = identity) - checkTrue(indicator$unwound) - checkErrorMessage(out, "err") - } - - test.stackUnwindsOnInterrupts <- function() { - if (.Platform$OS.type == "windows") { - return(NULL) - } - indicator <- newIndicator() - expr <- quote({ - repeat testSendInterrupt() - "returned" - }) - out <- tryCatch(evalUnwind(expr, indicator), interrupt = function(c) "onintr") - checkTrue(indicator$unwound) - checkIdentical(out, "onintr") - } - - test.stackUnwindsOnCaughtConditions <- function() { - indicator <- newIndicator() - expr <- quote(signalCondition(simpleCondition("cnd"))) - cnd <- tryCatch(evalUnwind(expr, indicator), condition = identity) - checkTrue(inherits(cnd, "simpleCondition")) - checkUnwound(indicator$unwound) - } - - test.stackUnwindsOnRestartJumps <- function() { - indicator <- newIndicator() - expr <- quote(invokeRestart("rst")) - out <- withRestarts(evalUnwind(expr, indicator), rst = function(...) "restarted") - checkIdentical(out, "restarted") - checkUnwound(indicator$unwound) - } - - test.stackUnwindsOnReturns <- function() { - indicator <- newIndicator() - expr <- quote(signalCondition(simpleCondition(NULL))) - out <- callCC(function(k) { - withCallingHandlers(evalUnwind(expr, indicator), - simpleCondition = function(e) k("jumped") - ) - }) - checkIdentical(out, "jumped") - checkUnwound(indicator$unwound) - } - - test.stackUnwindsOnReturnedConditions <- function() { - indicator <- newIndicator() - cnd <- simpleError("foo") - out <- tryCatch(evalUnwind(quote(cnd), indicator), - error = function(c) "abort" - ) - checkTrue(indicator$unwound) - - # The old mechanism cannot differentiate between a returned error and a - # thrown error - if (hasUnwind) { - checkIdentical(out, cnd) - } else { - checkIdentical(out, "abort") - } - } - - # Longjump from the inner protected eval - test.stackUnwindsOnNestedEvalsInner <- function() { - indicator1 <- newIndicator() - indicator2 <- newIndicator() - innerUnwindExpr <- quote(evalUnwind(quote(invokeRestart("here", "jump")), indicator2)) - out <- withRestarts( - here = identity, - evalUnwind(innerUnwindExpr, indicator1) - ) - - checkIdentical(out, "jump") - checkUnwound(indicator1$unwound) - checkUnwound(indicator2$unwound) - } - - # Longjump from the outer protected eval - test.stackUnwindsOnNestedEvalsOuter <- function() { - indicator1 <- newIndicator() - indicator2 <- newIndicator() - innerUnwindExpr <- quote({ - evalUnwind(NULL, indicator2) - invokeRestart("here", "jump") - }) - out <- withRestarts( - here = identity, - evalUnwind(innerUnwindExpr, indicator1) - ) - - checkIdentical(out, "jump") - checkUnwound(indicator1$unwound) - checkTrue(indicator2$unwound) # Always unwound - } - - test.unwindProtect <- function() { - if (hasUnwind) { - indicator <- newIndicator() - checkException(testUnwindProtect(indicator, fail = TRUE)) - checkTrue(indicator$unwound) - - indicator <- newIndicator() - checkException(testUnwindProtectLambda(indicator, fail = TRUE)) - checkTrue(indicator$unwound) - - indicator <- newIndicator() - checkException(testUnwindProtectFunctionObject(indicator, fail = TRUE)) - checkTrue(indicator$unwound) - - indicator <- newIndicator() - checkEquals(testUnwindProtect(indicator, fail = FALSE), 42) - checkTrue(indicator$unwound) - - indicator <- newIndicator() - checkEquals(testUnwindProtectLambda(indicator, fail = FALSE), 42) - checkTrue(indicator$unwound) - - indicator <- newIndicator() - checkEquals(testUnwindProtectFunctionObject(indicator, fail = FALSE), 420) - checkTrue(indicator$unwound) - } - } -} diff --git a/inst/unitTests/runit.stats.R b/inst/unitTests/runit.stats.R deleted file mode 100644 index 9e8800062..000000000 --- a/inst/unitTests/runit.stats.R +++ /dev/null @@ -1,333 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("stats.cpp") - - test.stats.dbeta <- function() { - vv <- seq(0, 1, by = 0.1) - a <- 0.5; b <- 2.5 - checkEquals(runit_dbeta(vv, a, b), - list( - NoLog = dbeta(vv, a, b), - Log = dbeta(vv, a, b, log=TRUE) - ), - msg = " stats.qbeta") - } - - test.stats.dbinom <- function( ){ - v <- 1:10 - checkEquals(runit_dbinom(v) , - list( - false = dbinom(v, 10, .5), - true = dbinom(v, 10, .5, TRUE ) - ), msg = "stats.dbinom" ) - } - - test.stats.dunif <- function() { - vv <- seq(0, 1, by = 0.1) - checkEquals(runit_dunif(vv), - list( - NoLog_noMin_noMax = dunif(vv), - NoLog_noMax = dunif(vv, 0), - NoLog = dunif(vv, 0, 1), - Log = dunif(vv, 0, 1, log=TRUE), - Log_noMax = dunif(vv, 0, log=TRUE) - #,Log_noMin_noMax = dunif(vv, log=TRUE) ## wrong answer - ), - msg = " stats.dunif") - } - - test.stats.dgamma <- function( ) { - v <- 1:4 - checkEquals(runit_dgamma(v), - list( NoLog = dgamma(v, 1.0, 1.0), - Log = dgamma(v, 1.0, 1.0, log = TRUE ), - Log_noRate = dgamma(v, 1.0, log = TRUE ) - ), msg = "stats.dgamma" ) - } - - - test.stats.dpois <- function( ){ - v <- 0:5 - checkEquals(runit_dpois(v) , - list( false = dpois(v, .5), - true = dpois(v, .5, TRUE ) - ), msg = "stats.dpois" ) - } - - test.stats.dnorm <- function( ) { - v <- seq(0.0, 1.0, by=0.1) - checkEquals(runit_dnorm(v), - list( false_noMean_noSd = dnorm(v), - false_noSd = dnorm(v, 0.0), - false = dnorm(v, 0.0, 1.0), - true = dnorm(v, 0.0, 1.0, log=TRUE ), - true_noSd = dnorm(v, 0.0, log=TRUE ), - true_noMean_noSd = dnorm(v, log=TRUE ) - ), msg = "stats.dnorm" ) - } - - test.stats.dt <- function( ) { - v <- seq(0.0, 1.0, by=0.1) - checkEquals(runit_dt(v), - list( false = dt(v, 5), - true = dt(v, 5, log=TRUE ) # NB: need log=TRUE here - ), msg = "stats.dt" ) - } - - test.stats.pbeta <- function( ) { - a <- 0.5; b <- 2.5 - v <- qbeta(seq(0.0, 1.0, by=0.1), a, b) - checkEquals(runit_pbeta(v, a, b), - list(lowerNoLog = pbeta(v, a, b), - lowerLog = pbeta(v, a, b, log=TRUE), - upperNoLog = pbeta(v, a, b, lower=FALSE), - upperLog = pbeta(v, a, b, lower=FALSE, log=TRUE) - ), - msg = " stats.pbeta" ) - ## Borrowed from R's d-p-q-r-tests.R - x <- c(.01, .10, .25, .40, .55, .71, .98) - pbval <- c(-0.04605755624088, -0.3182809860569, -0.7503593555585, - -1.241555830932, -1.851527837938, -2.76044482378, -8.149862739881) - checkEqualsNumeric(runit_pbeta(x, 0.8, 2)$upperLog, pbval, msg = " stats.pbeta") - checkEqualsNumeric(runit_pbeta(1-x, 2, 0.8)$lowerLog, pbval, msg = " stats.pbeta") - } - - test.stats.pbinom <- function( ) { - n <- 20 - p <- 0.5 - vv <- 0:n - checkEquals(runit_pbinom(vv, n, p), - list(lowerNoLog = pbinom(vv, n, p), - lowerLog = pbinom(vv, n, p, log=TRUE), - upperNoLog = pbinom(vv, n, p, lower=FALSE), - upperLog = pbinom(vv, n, p, lower=FALSE, log=TRUE) - ), - msg = " stats.pbinom") - } - - test.stats.pcauchy <- function( ) { - location <- 0.5 - scale <- 1.5 - vv <- 1:5 - checkEquals(runit_pcauchy(vv, location, scale), - list(lowerNoLog = pcauchy(vv, location, scale), - lowerLog = pcauchy(vv, location, scale, log=TRUE), - upperNoLog = pcauchy(vv, location, scale, lower=FALSE), - upperLog = pcauchy(vv, location, scale, lower=FALSE, log=TRUE) - ), - msg = " stats.pcauchy") - } - - test.stats.punif <- function( ) { - v <- qunif(seq(0.0, 1.0, by=0.1)) - checkEquals(runit_punif(v), - list(lowerNoLog = punif(v), - lowerLog = punif(v, log=TRUE ), - upperNoLog = punif(v, lower=FALSE), - upperLog = punif(v, lower=FALSE, log=TRUE) - ), - msg = "stats.punif" ) - # TODO: also borrow from R's d-p-q-r-tests.R - } - - test.stats.pf <- function( ) { - v <- (1:9)/10 - checkEquals(runit_pf(v), - list(lowerNoLog = pf(v, 6, 8, lower=TRUE, log=FALSE), - lowerLog = pf(v, 6, 8, log=TRUE ), - upperNoLog = pf(v, 6, 8, lower=FALSE), - upperLog = pf(v, 6, 8, lower=FALSE, log=TRUE) - ), - msg = "stats.pf" ) - } - - test.stats.pnf <- function( ) { - v <- (1:9)/10 - checkEquals(runit_pnf(v), - list(lowerNoLog = pf(v, 6, 8, ncp=2.5, lower=TRUE, log=FALSE), - lowerLog = pf(v, 6, 8, ncp=2.5, log=TRUE ), - upperNoLog = pf(v, 6, 8, ncp=2.5, lower=FALSE), - upperLog = pf(v, 6, 8, ncp=2.5, lower=FALSE, log=TRUE) - ), - msg = "stats.pnf" ) - } - - test.stats.pchisq <- function( ) { - v <- (1:9)/10 - checkEquals(runit_pchisq(v), - list(lowerNoLog = pchisq(v, 6, lower=TRUE, log=FALSE), - lowerLog = pchisq(v, 6, log=TRUE ), - upperNoLog = pchisq(v, 6, lower=FALSE), - upperLog = pchisq(v, 6, lower=FALSE, log=TRUE) - ), - msg = "stats.pchisq" ) - } - - test.stats.pnchisq <- function( ) { - v <- (1:9)/10 - checkEquals(runit_pnchisq(v), - list(lowerNoLog = pchisq(v, 6, ncp=2.5, lower=TRUE, log=FALSE), - lowerLog = pchisq(v, 6, ncp=2.5, log=TRUE ), - upperNoLog = pchisq(v, 6, ncp=2.5, lower=FALSE), - upperLog = pchisq(v, 6, ncp=2.5, lower=FALSE, log=TRUE) - ), - msg = "stats.pnchisq" ) - } - - test.stats.pgamma <- function( ) { - v <- (1:9)/10 - checkEquals(runit_pgamma(v), - list(lowerNoLog = pgamma(v, shape = 2.0), - lowerLog = pgamma(v, shape = 2.0, log=TRUE ), - upperNoLog = pgamma(v, shape = 2.0, lower=FALSE), - upperLog = pgamma(v, shape = 2.0, lower=FALSE, log=TRUE) - ), - msg = "stats.pgamma" ) - } - - - test.stats.pnorm <- function( ) { - v <- qnorm(seq(0.0, 1.0, by=0.1)) - checkEquals(runit_pnorm(v), - list(lowerNoLog = pnorm(v), - lowerLog = pnorm(v, log=TRUE ), - upperNoLog = pnorm(v, lower=FALSE), - upperLog = pnorm(v, lower=FALSE, log=TRUE) - ), - msg = "stats.pnorm" ) - ## Borrowed from R's d-p-q-r-tests.R - z <- c(-Inf,Inf,NA,NaN, rt(1000, df=2)) - z.ok <- z > -37.5 | !is.finite(z) - pz <- runit_pnorm(z) - checkEqualsNumeric(pz$lowerNoLog, 1 - pz$upperNoLog, msg = "stats.pnorm") - checkEqualsNumeric(pz$lowerNoLog, runit_pnorm(-z)$upperNoLog, msg = "stats.pnorm") - checkEqualsNumeric(log(pz$lowerNoLog[z.ok]), pz$lowerLog[z.ok], msg = "stats.pnorm") - ## FIXME: Add tests that use non-default mu and sigma - } - - test.stats.ppois <- function( ) { - vv <- 0:20 - checkEquals(runit_ppois(vv), - list(lowerNoLog = ppois(vv, 0.5), - lowerLog = ppois(vv, 0.5, log=TRUE), - upperNoLog = ppois(vv, 0.5, lower=FALSE), - upperLog = ppois(vv, 0.5, lower=FALSE, log=TRUE) - ), - msg = " stats.ppois") - } - - test.stats.pt <- function( ) { - v <- seq(0.0, 1.0, by=0.1) - checkEquals(runit_pt(v), - list(lowerNoLog = pt(v, 5), - lowerLog = pt(v, 5, log=TRUE), - upperNoLog = pt(v, 5, lower=FALSE), - upperLog = pt(v, 5, lower=FALSE, log=TRUE) ), - msg = "stats.pt" ) - } - - test.stats.pnt <- function( ) { - v <- seq(0.0, 1.0, by=0.1) - checkEquals(runit_pnt(v), - list(lowerNoLog = pt(v, 5, ncp=7), - lowerLog = pt(v, 5, ncp=7, log=TRUE), - upperNoLog = pt(v, 5, ncp=7, lower=FALSE), - upperLog = pt(v, 5, ncp=7, lower=FALSE, log=TRUE) ), - msg = "stats.pnt" ) - } - - test.stats.qbinom <- function( ) { - n <- 20 - p <- 0.5 - vv <- seq(0, 1, by = 0.1) - checkEquals(runit_qbinom_prob(vv, n, p), - list(lower = qbinom(vv, n, p), - upper = qbinom(vv, n, p, lower=FALSE) - ), - msg = " stats.qbinom") - } - - test.stats.qunif <- function( ) { - checkEquals(runit_qunif_prob(c(0, 1, 1.1, -.1)), - list(lower = c(0, 1, NaN, NaN), - upper = c(1, 0, NaN, NaN) - ), - msg = "stats.qunif" ) - # TODO: also borrow from R's d-p-q-r-tests.R - } - - test.stats.qnorm <- function( ) { - checkEquals(runit_qnorm_prob(c(0, 1, 1.1, -.1)), - list(lower = c(-Inf, Inf, NaN, NaN), - upper = c(Inf, -Inf, NaN, NaN) - ), - msg = "stats.qnorm" ) - ## Borrowed from R's d-p-q-r-tests.R and Wichura (1988) - checkEqualsNumeric(runit_qnorm_prob(c( 0.25, .001, 1e-20))$lower, - c(-0.6744897501960817, -3.090232306167814, -9.262340089798408), - msg = "stats.qnorm", - tol = 1e-15) - - checkEquals(runit_qnorm_log(c(-Inf, 0, 0.1)), - list(lower = c(-Inf, Inf, NaN), - upper = c(Inf, -Inf, NaN) - ), - msg = "stats.qnorm" ) - checkEqualsNumeric(runit_qnorm_log(-1e5)$lower, -447.1974945) - } - - test.stats.qpois.prob <- function( ) { - vv <- seq(0, 1, by = 0.1) - checkEquals(runit_qpois_prob(vv), - list(lower = qpois(vv, 0.5), - upper = qpois(vv, 0.5, lower=FALSE) - ), - msg = " stats.qpois.prob") - } - - test.stats.qt <- function( ) { - v <- seq(0.05, 0.95, by=0.05) - ( x1 <- runit_qt(v, 5, FALSE, FALSE) ) - ( x2 <- qt(v, df=5, lower=FALSE, log=FALSE) ) - checkEquals(x1, x2, msg="stats.qt.f.f") - - ( x1 <- runit_qt(v, 5, TRUE, FALSE) ) - ( x2 <- qt(v, df=5, lower=TRUE, log=FALSE) ) - checkEquals(x1, x2, msg="stats.qt.t.f") - - ( x1 <- runit_qt(-v, 5, FALSE, TRUE) ) - ( x2 <- qt(-v, df=5, lower=FALSE, log=TRUE) ) - checkEquals(x1, x2, msg="stats.qt.f.t") - - ( x1 <- runit_qt(-v, 5, TRUE, TRUE) ) - ( x2 <- qt(-v, df=5, lower=TRUE, log=TRUE) ) - checkEquals(x1, x2, msg="stats.qt.t.t") - - } - - ## TODO: test.stats.qgamma - ## TODO: test.stats.(dq)chisq - -} diff --git a/inst/unitTests/runit.subset.R b/inst/unitTests/runit.subset.R deleted file mode 100644 index 61b591322..000000000 --- a/inst/unitTests/runit.subset.R +++ /dev/null @@ -1,95 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2014 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("Subset.cpp") - - test.subset <- function() { - - x <- rnorm(5) - names(x) <- letters[1:5] - - checkIdentical( x[c(1, 2, 3)], subset_test_int(x, c(0L, 1L, 2L)) ) - checkException( subset_test_int(x, -1L) ) - checkException( subset_test_int(x, length(x)) ) - - checkIdentical( x[c(1, 2, 3)], subset_test_num(x, c(0, 1, 2)), - "numeric subsetting") - - checkIdentical( x[ c('b', 'a') ], subset_test_char(x, c('b', 'a')), - "character subsetting") - - checkException( subset_test_char( c(1, 2, 3), 'a' ), - "character subsetting -- no names on x") - - lgcl <- c(TRUE, FALSE, TRUE, TRUE, FALSE) - checkIdentical( - x[lgcl], - subset_test_lgcl(x, lgcl), - "logical subsetting" ) - - names(x) <- c('a', 'b', 'b', 'c', 'd') - checkIdentical( - x['b'], - subset_test_char(x, 'b'), - "character subsetting -- duplicated name") - - l <- as.list(x) - checkIdentical( - l[c('b', 'c')], - subset_test_list(x, c('b', 'c')), - "list subsetting") - - checkIdentical( - x[ x > 0 ], - subset_test_greater_0(x), - "sugar subsetting (x[x > 0])") - - x <- as.numeric(-2:2) - checkIdentical( - c(-2, -1, 0, 0, 0), - subset_test_assign(x) - ) - - attr(x, "foo") <- "bar" - y <- subset_test_int(x, 0L) - checkIdentical( attr(y, "foo"), "bar" ) - - checkIdentical(subset_assign_subset(1:6), c(0,0,0,4,5,6)) - - checkIdentical(subset_assign_subset2(1:6), c(4,5,6,0,0,0)) - - checkIdentical(subset_assign_subset3(1:6), c(4,4,4,0,0,0)) - - checkIdentical(subset_assign_subset4(seq(2, 4, 0.2)), c(2L,2L,2L,2L,2L,3L,0L,0L,0L,0L,0L)) - - checkException(subset_assign_subset5(1:6), msg = "index error") - - checkIdentical(subset_assign_vector_size_1(1:6,7), c(7,7,7,4,5,6)) - - x <- rnorm(10) - y <- sample(10, 5) - checkIdentical(subset_sugar_add(x, y - 1L), x[y] + x[y]) - } - -} diff --git a/inst/unitTests/runit.sugar.R b/inst/unitTests/runit.sugar.R deleted file mode 100644 index b17d7a631..000000000 --- a/inst/unitTests/runit.sugar.R +++ /dev/null @@ -1,2199 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; ess-indent-level: 4; indent-tabs-mode: nil; -*- -# -# Copyright (C) 2010 - 2015 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("sugar.cpp") - - test.sugar.abs <- function( ){ - x <- rnorm(10) - y <- -10:10 - checkEquals( runit_abs(x,y) , list( abs(x), abs(y) ) ) - } - - test.sugar.all.one.less <- function( ){ - checkTrue( runit_all_one_less( 1 ) ) - checkTrue( ! runit_all_one_less( 1:10 ) ) - checkTrue( is.na( runit_all_one_less( NA ) ) ) - checkTrue( is.na( runit_all_one_less( c( NA, 1) ) ) ) - checkTrue( ! runit_all_one_less( c( 6, NA) ) ) - } - - test.sugar.all.one.greater <- function( ){ - checkTrue( ! runit_all_one_greater( 1 ) ) - checkTrue( ! runit_all_one_greater( 1:10 ) ) - checkTrue( runit_all_one_greater( 6:10 ) ) - checkTrue( ! runit_all_one_greater( c(NA, 1) ) ) - checkTrue( is.na( runit_all_one_greater( c(NA, 6) ) ) ) - } - - test.sugar.all.one.less.or.equal <- function( ){ - checkTrue( runit_all_one_less_or_equal( 1 ) ) - checkTrue( ! runit_all_one_less_or_equal( 1:10 ) ) - checkTrue( is.na( runit_all_one_less_or_equal( NA ) ) ) - checkTrue( is.na( runit_all_one_less_or_equal( c( NA, 1) ) ) ) - checkTrue( ! runit_all_one_less_or_equal( c( 6, NA) ) ) - checkTrue( runit_all_one_less_or_equal( 5 ) ) - - } - - test.sugar.all.one.greater.or.equal <- function( ){ - fx <- runit_all_one_greater_or_equal - checkTrue( ! fx( 1 ) ) - checkTrue( ! fx( 1:10 ) ) - checkTrue( fx( 6:10 ) ) - checkTrue( fx( 5 ) ) - checkTrue( ! fx( c(NA, 1) ) ) - checkTrue( is.na( fx( c(NA, 6) ) ) ) - } - - test.sugar.all.one.equal <- function( ){ - fx <- runit_all_one_equal - checkTrue( ! fx( 1 ) ) - checkTrue( ! fx( 1:2 ) ) - checkTrue( fx( rep(5,4) ) ) - checkTrue( is.na( fx( c(5,NA) ) ) ) - checkTrue(! fx( c(NA, 1) ) ) - } - - test.sugar.all.one.not.equal <- function( ){ - fx <- runit_all_not_equal_one - checkTrue( fx( 1 ) ) - checkTrue( fx( 1:2 ) ) - checkTrue( ! fx( 5 ) ) - checkTrue( is.na( fx( c(NA, 1) ) ) ) - checkTrue( ! fx( c(NA, 5) ) ) - } - - test.sugar.all.less <- function( ){ - fx <- runit_all_less - checkTrue( ! fx( 1, 0 ) ) - checkTrue( fx( 1:10, 2:11 ) ) - checkTrue( fx( 0, 1 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.all.greater <- function( ){ - fx <- runit_all_greater - checkTrue( fx( 1, 0 ) ) - checkTrue( fx( 2:11, 1:10 ) ) - checkTrue( ! fx( 0, 1 ) ) - checkTrue( ! fx( 0:9, c(0:8,10) ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.all.less.or.equal <- function( ){ - fx <- runit_all_less_or_equal - checkTrue( fx( 1, 1 ) ) - checkTrue( ! fx( 1:2, c(1,1) ) ) - checkTrue( fx( 0, 1 ) ) - checkTrue( ! fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.all.greater.or.equal <- function( ){ - fx <- runit_all_greater_or_equal - checkTrue( fx( 1, 1 ) ) - checkTrue( fx( 1:2, c(1,1) ) ) - checkTrue( ! fx( 0, 1 ) ) - checkTrue( fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.all.equal <- function( ){ - fx <- runit_all_equal - checkTrue( fx( 1, 1 ) ) - checkTrue( ! fx( 1:2, c(1,1) ) ) - checkTrue( ! fx( 0, 1 ) ) - checkTrue( ! fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.all.not.equal <- function( ){ - fx <- runit_all_not_equal - checkTrue( ! fx( 1, 1 ) ) - checkTrue( ! fx( 1:2, c(1,1) ) ) - checkTrue( fx( 0, 1 ) ) - checkTrue( fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - - } - - test.sugar.any.less <- function( ){ - fx <- runit_any_less - checkTrue( ! fx( 1, 0 ) ) - checkTrue( fx( 1:10, 2:11 ) ) - checkTrue( fx( 0, 1 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.any.greater <- function( ){ - fx <- runit_any_greater - checkTrue( fx( 1, 0 ) ) - checkTrue( fx( 2:11, 1:10 ) ) - checkTrue( ! fx( 0, 1 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.any.less.or.equal <- function( ){ - fx <- runit_any_less_or_equal - checkTrue( fx( 1, 1 ) ) - checkTrue( fx( 1:2, c(1,1) ) ) - checkTrue( fx( 0, 1 ) ) - checkTrue( ! fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.any.greater.or.equal <- function( ){ - fx <- runit_any_greater_or_equal - checkTrue( fx( 1, 1 ) ) - checkTrue( fx( 1:2, c(1,1) ) ) - checkTrue( ! fx( 0, 1 ) ) - checkTrue( fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.any.equal <- function( ){ - fx <- runit_any_equal - checkTrue( fx( 1, 1 ) ) - checkTrue( fx( 1:2, c(1,1) ) ) - checkTrue( ! fx( 0, 1 ) ) - checkTrue( ! fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.any.not.equal <- function( ){ - fx <- runit_any_not_equal - checkTrue( ! fx( 1, 1 ) ) - checkTrue( fx( 1:2, c(1,1) ) ) - checkTrue( fx( 0, 1 ) ) - checkTrue( fx( 1, 0 ) ) - checkTrue( is.na( fx( NA, 1 ) ) ) - } - - test.sugar.constructor <- function( ){ - fx <- runit_constructor - checkEquals( fx( 1, 0 ), FALSE ) - checkEquals( fx( 1:10, 2:11 ), rep(TRUE,10) ) - checkEquals( fx( 0, 1 ), TRUE ) - checkTrue( identical( fx( NA, 1 ), NA ) ) - } - - test.sugar.assignment <- function( ){ - fx <- runit_assignment - checkEquals( fx( 1, 0 ), FALSE ) - checkEquals( fx( 1:10, 2:11 ), rep(TRUE,10) ) - checkEquals( fx( 0, 1 ), TRUE ) - checkTrue( identical( fx( NA, 1 ), NA ) ) - } - - test.sugar.diff <- function( ){ - x <- as.integer(round(rnorm(100,1,100))) - checkEquals( runit_diff_int(x) , diff(x) ) - x <- rnorm( 100 ) - checkEquals( runit_diff(x) , diff(x) ) - y <- rnorm(100) - pred <- sample( c(T,F), 99, replace = TRUE ) - checkEquals( runit_diff_ifelse(pred, x, y ), ifelse( pred, diff(x), diff(y) ) ) - } - - test.sugar.exp <- function( ){ - fx <- runit_exp - x <- rnorm(10) - y <- -10:10 - checkEquals( fx(x,y) , list( exp(x), exp(y) ) ) - } - - test.sugar.floor <- function( ){ - fx <- runit_floor - x <- rnorm(10) - y <- -10:10 - checkEquals( fx(x,y) , list( floor(x), floor(y) ) ) - } - - test.sugar.ceil <- function( ){ - fx <- runit_ceil - x <- rnorm(10) - y <- -10:10 - checkEquals( fx(x,y) , list( ceiling(x), ceiling(y) ) ) - } - - test.sugar.pow <- function( ){ - fx <- runit_pow - x <- rnorm(10) - y <- -10:10 - checkEquals( fx(x,y) , list( x^3L , y^2.3 ) ) - } - - test.sugar.ifelse <- function( ){ - fx <- runit_ifelse - x <- 1:10 - y <- 10:1 - checkEquals(fx( x, y), - list("vec_vec" = ifelse( x x, x <= 2, 2 != x), - "sugar vector scalar logical operations") - } - - test.vector.vector.ops <- function( ){ - x <- rnorm(10) - y <- runif(10) - checkEquals(vector_vector_ops(x,y), - list(x + y, y - x, x * y, y / x), - "sugar vector vector operations") - } - - test.vector.vector.logical <- function( ){ - x <- rnorm(10) - y <- runif(10) - checkEquals(vector_vector_logical(x,y), - list(x < y, x > y, x <= y, x >= y, x == y, x != y), - "sugar vector vector operations") - } - - ## Additions made 1 Jan 2015 - - test.mean.integer <- function() { - v1 <- seq(-100L, 100L) - v2 <- c(v1, NA) - checkEquals(mean(v1), meanInteger(v1), "mean of integer vector") - checkEquals(mean(v2), meanInteger(v2), "mean of integer vector with NA") - } - - test.mean.numeric <- function() { - v1 <- seq(-100, 100) - v2 <- c(v1, NA) - v3 <- c(v1, Inf) - checkEquals(mean(v1), meanNumeric(v1), "mean of numeric vector") - checkEquals(mean(v2), meanNumeric(v2), "mean of numeric vector with NA") - checkEquals(mean(v3), meanNumeric(v3), "mean of numeric vector with Inf") - } - - test.mean.complex <- function() { - v1 <- seq(-100, 100) + 1.0i - v2 <- c(v1, NA) - v3 <- c(v1, Inf) - checkEquals(mean(v1), meanComplex(v1), "mean of complex vector") - checkEquals(mean(v2), meanComplex(v2), "mean of complex vector with NA") - checkEquals(mean(v3), meanComplex(v3), "mean of complex vector with Inf") - } - - test.mean.logical <- function() { - v1 <- c(rep(TRUE, 50), rep(FALSE, 25)) - v2 <- c(v1, NA) - checkEquals(mean(v1), meanLogical(v1), "mean of logical vector") - checkEquals(mean(v2), meanLogical(v2), "mean of logical vector with NA") - } - - - ## 30 Oct 2015: cumprod, cummin, cummax - # base::cumprod defined for numeric, integer, and complex vectors - test.sugar.cumprod_nv <- function() { - fx <- runit_cumprod_nv - x <- rnorm(10) - checkEquals(fx(x), cumprod(x)) - x[4] <- NA - checkEquals(fx(x), cumprod(x)) - } - - test.sugar.cumprod_iv <- function() { - fx <- runit_cumprod_iv - x <- as.integer(rpois(10, 5)) - checkEquals(fx(x), cumprod(x)) - x[4] <- NA - checkEquals(fx(x), cumprod(x)) - } - - test.sugar.cumprod_cv <- function() { - fx <- runit_cumprod_cv - x <- rnorm(10) + 2i - checkEquals(fx(x), cumprod(x)) - x[4] <- NA - checkEquals(fx(x), cumprod(x)) - } - - # base::cummin defined for numeric and integer vectors - test.sugar.cummin_nv <- function() { - fx <- runit_cummin_nv - x <- rnorm(10) - checkEquals(fx(x), cummin(x)) - x[4] <- NA - checkEquals(fx(x), cummin(x)) - } - - test.sugar.cummin_iv <- function() { - fx <- runit_cummin_iv - x <- as.integer(rpois(10, 5)) - checkEquals(fx(x), cummin(x)) - x[4] <- NA - checkEquals(fx(x), cummin(x)) - } - - # base::cummax defined for numeric and integer vectors - test.sugar.cummax_nv <- function() { - fx <- runit_cummax_nv - x <- rnorm(10) - checkEquals(fx(x), cummax(x)) - x[4] <- NA - checkEquals(fx(x), cummax(x)) - } - - test.sugar.cummax_iv <- function() { - fx <- runit_cummax_iv - x <- as.integer(rpois(10, 5)) - checkEquals(fx(x), cummax(x)) - x[4] <- NA - checkEquals(fx(x), cummax(x)) - } - - - ## 18 January 2016: median - ## median of integer vector - test.sugar.median_int <- function() { - fx <- median_int - - x <- as.integer(rpois(5, 20)) - checkEquals(fx(x), median(x), - "median_int / odd length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), median(x), - "median_int / odd length / with NA / na.rm = FALSE") - - checkEquals(fx(x, TRUE), median(x, TRUE), - "median_int / odd length / with NA / na.rm = TRUE") - - ## - x <- as.integer(rpois(6, 20)) - checkEquals(fx(x), median(x), - "median_int / even length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), median(x), - "median_int / even length / with NA / na.rm = FALSE") - - checkEquals(fx(x, TRUE), median(x, TRUE), - "median_int / even length / with NA / na.rm = TRUE") - } - - ## median of numeric vector - test.sugar.median_dbl <- function() { - fx <- median_dbl - - x <- rnorm(5) - checkEquals(fx(x), median(x), - "median_dbl / odd length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), median(x), - "median_dbl / odd length / with NA / na.rm = FALSE") - - checkEquals(fx(x, TRUE), median(x, TRUE), - "median_dbl / odd length / with NA / na.rm = TRUE") - - ## - x <- rnorm(6) - checkEquals(fx(x), median(x), - "median_dbl / even length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), median(x), - "median_dbl / even length / with NA / na.rm = FALSE") - - checkEquals(fx(x, TRUE), median(x, TRUE), - "median_dbl / even length / with NA / na.rm = TRUE") - } - - ## median of complex vector - test.sugar.median_cx <- function() { - fx <- median_cx - - x <- rnorm(5) + 2i - checkEquals(fx(x), median(x), - "median_cx / odd length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), median(x), - "median_cx / odd length / with NA / na.rm = FALSE") - - checkEquals(fx(x, TRUE), median(x, TRUE), - "median_cx / odd length / with NA / na.rm = TRUE") - - ## - x <- rnorm(6) + 2i - checkEquals(fx(x), median(x), - "median_cx / even length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), median(x), - "median_cx / even length / with NA / na.rm = FALSE") - - checkEquals(fx(x, TRUE), median(x, TRUE), - "median_cx / even length / with NA / na.rm = TRUE") - } - - ## median of character vector - test.sugar.median_ch <- function() { - fx <- median_ch - - x <- sample(letters, 5) - checkEquals(fx(x), median(x), - "median_ch / odd length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), median(x), - "median_ch / odd length / with NA / na.rm = FALSE") - - ## median(x, TRUE) returns NA_real_ for character vector input - ## which results in a warning; i.e. if the vector it passes to - ## `mean.default(sort(x, partial = half + 0L:1L)[half + 0L:1L])` - ## has ((length(x) %% 2) == 0) - - checkEquals(fx(x, TRUE), - as.character(suppressWarnings(median(x, TRUE))), - "median_ch / odd length / with NA / na.rm = TRUE") - - ## - x <- sample(letters, 6) - checkEquals(fx(x), - as.character(suppressWarnings(median(x))), - "median_ch / even length / no NA / na.rm = FALSE") - - x[4] <- NA - checkEquals(fx(x), - as.character(suppressWarnings(median(x))), - "median_ch / even length / with NA / na.rm = FALSE") - - checkEquals(fx(x, TRUE), - as.character(suppressWarnings(median(x, TRUE))), - "median_ch / even length / with NA / na.rm = TRUE") - } - - - ## 12 March 2016 - ## cbind numeric tests - test.sugar.cbind_numeric <- function() { - - m1 <- matrix(rnorm(9), 3, 3); m2 <- matrix(rnorm(9), 3, 3) - v1 <- rnorm(3); v2 <- rnorm(3) - s1 <- rnorm(1); s2 <- rnorm(1) - - cbind <- function(...) { - base::cbind(..., deparse.level = 0) - } - - checkEquals(n_cbind_mm(m1, m2), cbind(m1, m2), - "numeric cbind / matrix matrix") - - checkEquals(n_cbind_mv(m1, v1), cbind(m1, v1), - "numeric cbind / matrix vector") - - checkEquals(n_cbind_ms(m1, s1), cbind(m1, s1), - "numeric cbind / matrix scalar") - - checkEquals(n_cbind_vv(v1, v2), cbind(v1, v2), - "numeric cbind / vector vector") - - checkEquals(n_cbind_vm(v1, m1), cbind(v1, m1), - "numeric cbind / vector matrix") - - checkEquals(n_cbind_vs(v1, s1), cbind(v1, s1), - "numeric cbind / vector scalar") - - checkEquals(n_cbind_ss(s1, s2), cbind(s1, s2), - "numeric cbind / scalar scalar") - - checkEquals(n_cbind_sm(s1, m1), cbind(s1, m1), - "numeric cbind / scalar matrix") - - checkEquals(n_cbind_sv(s1, v1), cbind(s1, v1), - "numeric cbind / scalar vector") - - checkEquals(n_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), - cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), - "numeric cbind 9") - - } - - ## cbind integer tests - test.sugar.cbind_integer <- function() { - - m1 <- matrix(rpois(9, 20), 3, 3); m2 <- matrix(rpois(9, 20), 3, 3) - v1 <- rpois(3, 30); v2 <- rpois(3, 30) - s1 <- rpois(1, 40); s2 <- rpois(1, 40) - - cbind <- function(...) { - base::cbind(..., deparse.level = 0) - } - - checkEquals(i_cbind_mm(m1, m2), cbind(m1, m2), - "integer cbind / matrix matrix") - - checkEquals(i_cbind_mv(m1, v1), cbind(m1, v1), - "integer cbind / matrix vector") - - checkEquals(i_cbind_ms(m1, s1), cbind(m1, s1), - "integer cbind / matrix scalar") - - checkEquals(i_cbind_vv(v1, v2), cbind(v1, v2), - "integer cbind / vector vector") - - checkEquals(i_cbind_vm(v1, m1), cbind(v1, m1), - "integer cbind / vector matrix") - - checkEquals(i_cbind_vs(v1, s1), cbind(v1, s1), - "integer cbind / vector scalar") - - checkEquals(i_cbind_ss(s1, s2), cbind(s1, s2), - "integer cbind / scalar scalar") - - checkEquals(i_cbind_sm(s1, m1), cbind(s1, m1), - "integer cbind / scalar matrix") - - checkEquals(i_cbind_sv(s1, v1), cbind(s1, v1), - "integer cbind / scalar vector") - - checkEquals(i_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), - cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), - "integer cbind 9") - - } - - ## cbind complex tests - test.sugar.cbind_complex <- function() { - - m1 <- matrix(rnorm(9), 3, 3) + 2i - m2 <- matrix(rnorm(9), 3, 3) + 5i - v1 <- rnorm(3) + 3i; v2 <- rnorm(3) + 4i - s1 <- rnorm(1) + 4i; s2 <- rnorm(1) + 5i - - cbind <- function(...) { - base::cbind(..., deparse.level = 0) - } - - checkEquals(cx_cbind_mm(m1, m2), cbind(m1, m2), - "complex cbind / matrix matrix") - - checkEquals(cx_cbind_mv(m1, v1), cbind(m1, v1), - "complex cbind / matrix vector") - - checkEquals(cx_cbind_ms(m1, s1), cbind(m1, s1), - "complex cbind / matrix scalar") - - checkEquals(cx_cbind_vv(v1, v2), cbind(v1, v2), - "complex cbind / vector vector") - - checkEquals(cx_cbind_vm(v1, m1), cbind(v1, m1), - "complex cbind / vector matrix") - - checkEquals(cx_cbind_vs(v1, s1), cbind(v1, s1), - "complex cbind / vector scalar") - - checkEquals(cx_cbind_ss(s1, s2), cbind(s1, s2), - "complex cbind / scalar scalar") - - checkEquals(cx_cbind_sm(s1, m1), cbind(s1, m1), - "complex cbind / scalar matrix") - - checkEquals(cx_cbind_sv(s1, v1), cbind(s1, v1), - "complex cbind / scalar vector") - - checkEquals(cx_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), - cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), - "complex cbind 9") - - } - - ## cbind logical tests - test.sugar.cbind_logical <- function() { - - m1 <- matrix(as.logical(rbinom(9, 1, .5)), 3, 3) - m2 <- matrix(as.logical(rbinom(9, 1, .5)), 3, 3) - v1 <- as.logical(rbinom(3, 1, .5)) - v2 <- as.logical(rbinom(3, 1, .5)) - s1 <- as.logical(rbinom(1, 1, .5)) - s2 <- as.logical(rbinom(1, 1, .5)) - - cbind <- function(...) { - base::cbind(..., deparse.level = 0) - } - - checkEquals(l_cbind_mm(m1, m2), cbind(m1, m2), - "logical cbind / matrix matrix") - - checkEquals(l_cbind_mv(m1, v1), cbind(m1, v1), - "logical cbind / matrix vector") - - checkEquals(l_cbind_ms(m1, s1), cbind(m1, s1), - "logical cbind / matrix scalar") - - checkEquals(l_cbind_vv(v1, v2), cbind(v1, v2), - "logical cbind / vector vector") - - checkEquals(l_cbind_vm(v1, m1), cbind(v1, m1), - "logical cbind / vector matrix") - - checkEquals(l_cbind_vs(v1, s1), cbind(v1, s1), - "logical cbind / vector scalar") - - checkEquals(l_cbind_ss(s1, s2), cbind(s1, s2), - "logical cbind / scalar scalar") - - checkEquals(l_cbind_sm(s1, m1), cbind(s1, m1), - "logical cbind / scalar matrix") - - checkEquals(l_cbind_sv(s1, v1), cbind(s1, v1), - "logical cbind / scalar vector") - - checkEquals(l_cbind9(m1, v1, s1, m2, v2, s2, m1, v1, s1), - cbind(m1, v1, s1, m2, v2, s2, m1, v1, s1), - "logical cbind 9") - - } - - ## cbind character tests - test.sugar.cbind_character <- function() { - - m1 <- matrix(sample(letters, 9, TRUE), 3, 3) - m2 <- matrix(sample(LETTERS, 9, TRUE), 3, 3) - v1 <- sample(letters, 3, TRUE) - v2 <- sample(LETTERS, 3, TRUE) - - cbind <- function(...) { - base::cbind(..., deparse.level = 0) - } - - checkEquals(c_cbind_mm(m1, m2), cbind(m1, m2), - "logical cbind / matrix matrix") - - checkEquals(c_cbind_mv(m1, v1), cbind(m1, v1), - "logical cbind / matrix vector") - - checkEquals(c_cbind_vv(v1, v2), cbind(v1, v2), - "logical cbind / vector vector") - - checkEquals(c_cbind_vm(v1, m1), cbind(v1, m1), - "logical cbind / vector matrix") - - checkEquals(c_cbind6(m1, v1, m2, v2, m1, v1), - cbind(m1, v1, m2, v2, m1, v1), - "character cbind 6") - - } - - - ## 04 September 2016 - ## {row,col}{Sums,Means} numeric tests - test.sugar.rowMeans_numeric <- function() { - - x <- matrix(rnorm(9), 3) - - checkEquals( - dbl_row_sums(x), rowSums(x), - "numeric / rowSums / keep NA / clean input" - ) - checkEquals( - dbl_row_sums(x, TRUE), rowSums(x, TRUE), - "numeric / rowSums / rm NA / clean input" - ) - - checkEquals( - dbl_col_sums(x), colSums(x), - "numeric / colSums / keep NA / clean input" - ) - checkEquals( - dbl_col_sums(x, TRUE), colSums(x, TRUE), - "numeric / colSums / rm NA / clean input" - ) - - checkEquals( - dbl_row_means(x), rowMeans(x), - "numeric / rowMeans / keep NA / clean input" - ) - checkEquals( - dbl_row_means(x, TRUE), rowMeans(x, TRUE), - "numeric / rowMeans / rm NA / clean input" - ) - - checkEquals( - dbl_col_means(x), colMeans(x), - "numeric / colMeans / keep NA / clean input" - ) - checkEquals( - dbl_col_means(x, TRUE), colMeans(x, TRUE), - "numeric / colMeans / rm NA / clean input" - ) - - - x[sample(1:9, 4)] <- NA - - checkEquals( - dbl_row_sums(x), rowSums(x), - "numeric / rowSums / keep NA / mixed input" - ) - checkEquals( - dbl_row_sums(x, TRUE), rowSums(x, TRUE), - "numeric / rowSums / rm NA / mixed input" - ) - - checkEquals( - dbl_col_sums(x), colSums(x), - "numeric / colSums / keep NA / mixed input" - ) - checkEquals( - dbl_col_sums(x, TRUE), colSums(x, TRUE), - "numeric / colSums / rm NA / mixed input" - ) - - checkEquals( - dbl_row_means(x), rowMeans(x), - "numeric / rowMeans / keep NA / mixed input" - ) - checkEquals( - dbl_row_means(x, TRUE), rowMeans(x, TRUE), - "numeric / rowMeans / rm NA / mixed input" - ) - - checkEquals( - dbl_col_means(x), colMeans(x), - "numeric / colMeans / keep NA / mixed input" - ) - checkEquals( - dbl_col_means(x, TRUE), colMeans(x, TRUE), - "numeric / colMeans / rm NA / mixed input" - ) - - - x[] <- NA_real_ - - checkEquals( - dbl_row_sums(x), rowSums(x), - "numeric / rowSums / keep NA / dirty input" - ) - checkEquals( - dbl_row_sums(x, TRUE), rowSums(x, TRUE), - "numeric / rowSums / rm NA / dirty input" - ) - - checkEquals( - dbl_col_sums(x), colSums(x), - "numeric / colSums / keep NA / dirty input" - ) - checkEquals( - dbl_col_sums(x, TRUE), colSums(x, TRUE), - "numeric / colSums / rm NA / dirty input" - ) - - checkEquals( - dbl_row_means(x), rowMeans(x), - "numeric / rowMeans / keep NA / dirty input" - ) - checkEquals( - dbl_row_means(x, TRUE), rowMeans(x, TRUE), - "numeric / rowMeans / rm NA / dirty input" - ) - - checkEquals( - dbl_col_means(x), colMeans(x), - "numeric / colMeans / keep NA / dirty input" - ) - checkEquals( - dbl_col_means(x, TRUE), colMeans(x, TRUE), - "numeric / colMeans / rm NA / dirty input" - ) - - } - - - ## {row,col}{Sums,Means} integer tests - test.sugar.rowMeans_integer <- function() { - - x <- matrix(as.integer(rnorm(9) * 1e4), 3) - - checkEquals( - int_row_sums(x), rowSums(x), - "integer / rowSums / keep NA / clean input" - ) - checkEquals( - int_row_sums(x, TRUE), rowSums(x, TRUE), - "integer / rowSums / rm NA / clean input" - ) - - checkEquals( - int_col_sums(x), colSums(x), - "integer / colSums / keep NA / clean input" - ) - checkEquals( - int_col_sums(x, TRUE), colSums(x, TRUE), - "integer / colSums / rm NA / clean input" - ) - - checkEquals( - int_row_means(x), rowMeans(x), - "integer / rowMeans / keep NA / clean input" - ) - checkEquals( - int_row_means(x, TRUE), rowMeans(x, TRUE), - "integer / rowMeans / rm NA / clean input" - ) - - checkEquals( - int_col_means(x), colMeans(x), - "integer / colMeans / keep NA / clean input" - ) - checkEquals( - int_col_means(x, TRUE), colMeans(x, TRUE), - "integer / colMeans / rm NA / clean input" - ) - - - x[sample(1:9, 4)] <- NA - - checkEquals( - int_row_sums(x), rowSums(x), - "integer / rowSums / keep NA / mixed input" - ) - checkEquals( - int_row_sums(x, TRUE), rowSums(x, TRUE), - "integer / rowSums / rm NA / mixed input" - ) - - checkEquals( - int_col_sums(x), colSums(x), - "integer / colSums / keep NA / mixed input" - ) - checkEquals( - int_col_sums(x, TRUE), colSums(x, TRUE), - "integer / colSums / rm NA / mixed input" - ) - - checkEquals( - int_row_means(x), rowMeans(x), - "integer / rowMeans / keep NA / mixed input" - ) - checkEquals( - int_row_means(x, TRUE), rowMeans(x, TRUE), - "integer / rowMeans / rm NA / mixed input" - ) - - checkEquals( - int_col_means(x), colMeans(x), - "integer / colMeans / keep NA / mixed input" - ) - checkEquals( - int_col_means(x, TRUE), colMeans(x, TRUE), - "integer / colMeans / rm NA / mixed input" - ) - - - x[] <- NA_integer_ - - checkEquals( - int_row_sums(x), rowSums(x), - "integer / rowSums / keep NA / dirty input" - ) - checkEquals( - int_row_sums(x, TRUE), rowSums(x, TRUE), - "integer / rowSums / rm NA / dirty input" - ) - - checkEquals( - int_col_sums(x), colSums(x), - "integer / colSums / keep NA / dirty input" - ) - checkEquals( - int_col_sums(x, TRUE), colSums(x, TRUE), - "integer / colSums / rm NA / dirty input" - ) - - checkEquals( - int_row_means(x), rowMeans(x), - "integer / rowMeans / keep NA / dirty input" - ) - checkEquals( - int_row_means(x, TRUE), rowMeans(x, TRUE), - "integer / rowMeans / rm NA / dirty input" - ) - - checkEquals( - int_col_means(x), colMeans(x), - "integer / colMeans / keep NA / dirty input" - ) - checkEquals( - int_col_means(x, TRUE), colMeans(x, TRUE), - "integer / colMeans / rm NA / dirty input" - ) - - } - - - ## {row,col}{Sums,Means} logical tests - test.sugar.rowMeans_logical <- function() { - - x <- matrix(rbinom(9, 1, .5) > 0, 3) - - checkEquals( - lgl_row_sums(x), rowSums(x), - "logical / rowSums / keep NA / clean input" - ) - checkEquals( - lgl_row_sums(x, TRUE), rowSums(x, TRUE), - "logical / rowSums / rm NA / clean input" - ) - - checkEquals( - lgl_col_sums(x), colSums(x), - "logical / colSums / keep NA / clean input" - ) - checkEquals( - lgl_col_sums(x, TRUE), colSums(x, TRUE), - "logical / colSums / rm NA / clean input" - ) - - checkEquals( - lgl_row_means(x), rowMeans(x), - "logical / rowMeans / keep NA / clean input" - ) - checkEquals( - lgl_row_means(x, TRUE), rowMeans(x, TRUE), - "logical / rowMeans / rm NA / clean input" - ) - - checkEquals( - lgl_col_means(x), colMeans(x), - "logical / colMeans / keep NA / clean input" - ) - checkEquals( - lgl_col_means(x, TRUE), colMeans(x, TRUE), - "logical / colMeans / rm NA / clean input" - ) - - - x[sample(1:9, 4)] <- NA - - checkEquals( - lgl_row_sums(x), rowSums(x), - "logical / rowSums / keep NA / mixed input" - ) - checkEquals( - lgl_row_sums(x, TRUE), rowSums(x, TRUE), - "logical / rowSums / rm NA / mixed input" - ) - - checkEquals( - lgl_col_sums(x), colSums(x), - "logical / colSums / keep NA / mixed input" - ) - checkEquals( - lgl_col_sums(x, TRUE), colSums(x, TRUE), - "logical / colSums / rm NA / mixed input" - ) - - checkEquals( - lgl_row_means(x), rowMeans(x), - "logical / rowMeans / keep NA / mixed input" - ) - checkEquals( - lgl_row_means(x, TRUE), rowMeans(x, TRUE), - "logical / rowMeans / rm NA / mixed input" - ) - - checkEquals( - lgl_col_means(x), colMeans(x), - "logical / colMeans / keep NA / mixed input" - ) - checkEquals( - lgl_col_means(x, TRUE), colMeans(x, TRUE), - "logical / colMeans / rm NA / mixed input" - ) - - - x[] <- NA_integer_ - - checkEquals( - lgl_row_sums(x), rowSums(x), - "logical / rowSums / keep NA / dirty input" - ) - checkEquals( - lgl_row_sums(x, TRUE), rowSums(x, TRUE), - "logical / rowSums / rm NA / dirty input" - ) - - checkEquals( - lgl_col_sums(x), colSums(x), - "logical / colSums / keep NA / dirty input" - ) - checkEquals( - lgl_col_sums(x, TRUE), colSums(x, TRUE), - "logical / colSums / rm NA / dirty input" - ) - - checkEquals( - lgl_row_means(x), rowMeans(x), - "logical / rowMeans / keep NA / dirty input" - ) - checkEquals( - lgl_row_means(x, TRUE), rowMeans(x, TRUE), - "logical / rowMeans / rm NA / dirty input" - ) - - checkEquals( - lgl_col_means(x), colMeans(x), - "logical / colMeans / keep NA / dirty input" - ) - checkEquals( - lgl_col_means(x, TRUE), colMeans(x, TRUE), - "logical / colMeans / rm NA / dirty input" - ) - - } - - - ## {row,col}{Sums,Means} complex tests - test.sugar.rowMeans_complex <- function() { - - x <- matrix(rnorm(9) + 2i, 3) - - checkEquals( - cx_row_sums(x), rowSums(x), - "complex / rowSums / keep NA / clean input" - ) - checkEquals( - cx_row_sums(x, TRUE), rowSums(x, TRUE), - "complex / rowSums / rm NA / clean input" - ) - - checkEquals( - cx_col_sums(x), colSums(x), - "complex / colSums / keep NA / clean input" - ) - checkEquals( - cx_col_sums(x, TRUE), colSums(x, TRUE), - "complex / colSums / rm NA / clean input" - ) - - checkEquals( - cx_row_means(x), rowMeans(x), - "complex / rowMeans / keep NA / clean input" - ) - checkEquals( - cx_row_means(x, TRUE), rowMeans(x, TRUE), - "complex / rowMeans / rm NA / clean input" - ) - - checkEquals( - cx_col_means(x), colMeans(x), - "complex / colMeans / keep NA / clean input" - ) - checkEquals( - cx_col_means(x, TRUE), colMeans(x, TRUE), - "complex / colMeans / rm NA / clean input" - ) - - - x[sample(1:9, 4)] <- NA - - checkEquals( - cx_row_sums(x), rowSums(x), - "complex / rowSums / keep NA / mixed input" - ) - checkEquals( - cx_row_sums(x, TRUE), rowSums(x, TRUE), - "complex / rowSums / rm NA / mixed input" - ) - - checkEquals( - cx_col_sums(x), colSums(x), - "complex / colSums / keep NA / mixed input" - ) - checkEquals( - cx_col_sums(x, TRUE), colSums(x, TRUE), - "complex / colSums / rm NA / mixed input" - ) - - checkEquals( - cx_row_means(x), rowMeans(x), - "complex / rowMeans / keep NA / mixed input" - ) - checkEquals( - cx_row_means(x, TRUE), rowMeans(x, TRUE), - "complex / rowMeans / rm NA / mixed input" - ) - - checkEquals( - cx_col_means(x), colMeans(x), - "complex / colMeans / keep NA / mixed input" - ) - checkEquals( - cx_col_means(x, TRUE), colMeans(x, TRUE), - "complex / colMeans / rm NA / mixed input" - ) - - - x[] <- NA_complex_ - - checkEquals( - cx_row_sums(x), rowSums(x), - "complex / rowSums / keep NA / dirty input" - ) - checkEquals( - cx_row_sums(x, TRUE), rowSums(x, TRUE), - "complex / rowSums / rm NA / dirty input" - ) - - checkEquals( - cx_col_sums(x), colSums(x), - "complex / colSums / keep NA / dirty input" - ) - checkEquals( - cx_col_sums(x, TRUE), colSums(x, TRUE), - "complex / colSums / rm NA / dirty input" - ) - - checkEquals( - cx_row_means(x), rowMeans(x), - "complex / rowMeans / keep NA / dirty input" - ) - checkEquals( - cx_row_means(x, TRUE), rowMeans(x, TRUE), - "complex / rowMeans / rm NA / dirty input" - ) - - checkEquals( - cx_col_means(x), colMeans(x), - "complex / colMeans / keep NA / dirty input" - ) - checkEquals( - cx_col_means(x, TRUE), colMeans(x, TRUE), - "complex / colMeans / rm NA / dirty input" - ) - - } - - - ## 10 December 2016 - ## sample.int tests - test.sugar.sample_dot_int <- function() { - - set.seed(123); s1 <- sample_dot_int(10, 5) - set.seed(123); s2 <- sample(10, 5) - - checkEquals( - s1, s2, - "sample.int / without replacement / without probability" - ) - - set.seed(123); s1 <- sample_dot_int(10, 5, TRUE) - set.seed(123); s2 <- sample(10, 5, TRUE) - - checkEquals( - s1, s2, - "sample.int / with replacement / without probability" - ) - - - px <- rep(c(3, 2, 1), length.out = 10) - set.seed(123); s1 <- sample_dot_int(10, 5, FALSE, px) - set.seed(123); s2 <- sample(10, 5, FALSE, px) - - checkEquals( - s1, s2, - "sample.int / without replacement / with probability" - ) - - set.seed(123); s1 <- sample_dot_int(10, 5, TRUE, px) - set.seed(123); s2 <- sample(10, 5, TRUE, px) - - checkEquals( - s1, s2, - "sample.int / with replacement / with probability" - ) - - } - - - ## sample_int tests - test.sugar.sample_int <- function() { - - x <- as.integer(rpois(10, 10)) - px <- rep(c(3, 2, 1), length.out = 10) - - set.seed(123); s1 <- sample_int(x, 6) - set.seed(123); s2 <- sample(x, 6) - - checkEquals( - s1, s2, - "sample_int / without replacement / without probability" - ) - - set.seed(123); s1 <- sample_int(x, 6, TRUE) - set.seed(123); s2 <- sample(x, 6, TRUE) - - checkEquals( - s1, s2, - "sample_int / with replacement / without probability" - ) - - set.seed(123); s1 <- sample_int(x, 6, FALSE, px) - set.seed(123); s2 <- sample(x, 6, FALSE, px) - - checkEquals( - s1, s2, - "sample_int / without replacement / with probability" - ) - - set.seed(123); s1 <- sample_int(x, 6, TRUE, px) - set.seed(123); s2 <- sample(x, 6, TRUE, px) - - checkEquals( - s1, s2, - "sample_int / with replacement / with probability" - ) - - } - - - ## sample_dbl tests - test.sugar.sample_dbl <- function() { - - x <- rnorm(10) - px <- rep(c(3, 2, 1), length.out = 10) - - set.seed(123); s1 <- sample_dbl(x, 6) - set.seed(123); s2 <- sample(x, 6) - - checkEquals( - s1, s2, - "sample_dbl / without replacement / without probability" - ) - - set.seed(123); s1 <- sample_dbl(x, 6, TRUE) - set.seed(123); s2 <- sample(x, 6, TRUE) - - checkEquals( - s1, s2, - "sample_dbl / with replacement / without probability" - ) - - set.seed(123); s1 <- sample_dbl(x, 6, FALSE, px) - set.seed(123); s2 <- sample(x, 6, FALSE, px) - - checkEquals( - s1, s2, - "sample_dbl / without replacement / with probability" - ) - - set.seed(123); s1 <- sample_dbl(x, 6, TRUE, px) - set.seed(123); s2 <- sample(x, 6, TRUE, px) - - checkEquals( - s1, s2, - "sample_dbl / with replacement / with probability" - ) - - } - - - ## sample_chr tests - test.sugar.sample_chr <- function() { - - x <- sample(letters, 10) - px <- rep(c(3, 2, 1), length.out = 10) - - set.seed(123); s1 <- sample_chr(x, 6) - set.seed(123); s2 <- sample(x, 6) - - checkEquals( - s1, s2, - "sample_chr / without replacement / without probability" - ) - - set.seed(123); s1 <- sample_chr(x, 6, TRUE) - set.seed(123); s2 <- sample(x, 6, TRUE) - - checkEquals( - s1, s2, - "sample_chr / with replacement / without probability" - ) - - set.seed(123); s1 <- sample_chr(x, 6, FALSE, px) - set.seed(123); s2 <- sample(x, 6, FALSE, px) - - checkEquals( - s1, s2, - "sample_chr / without replacement / with probability" - ) - - set.seed(123); s1 <- sample_chr(x, 6, TRUE, px) - set.seed(123); s2 <- sample(x, 6, TRUE, px) - - checkEquals( - s1, s2, - "sample_chr / with replacement / with probability" - ) - - } - - - ## sample_cx tests - test.sugar.sample_cx <- function() { - - x <- rnorm(10) + 2i - px <- rep(c(3, 2, 1), length.out = 10) - - set.seed(123); s1 <- sample_cx(x, 6) - set.seed(123); s2 <- sample(x, 6) - - checkEquals( - s1, s2, - "sample_cx / without replacement / without probability" - ) - - set.seed(123); s1 <- sample_cx(x, 6, TRUE) - set.seed(123); s2 <- sample(x, 6, TRUE) - - checkEquals( - s1, s2, - "sample_cx / with replacement / without probability" - ) - - set.seed(123); s1 <- sample_cx(x, 6, FALSE, px) - set.seed(123); s2 <- sample(x, 6, FALSE, px) - - checkEquals( - s1, s2, - "sample_cx / without replacement / with probability" - ) - - set.seed(123); s1 <- sample_cx(x, 6, TRUE, px) - set.seed(123); s2 <- sample(x, 6, TRUE, px) - - checkEquals( - s1, s2, - "sample_cx / with replacement / with probability" - ) - - } - - - ## sample_lgl tests - test.sugar.sample_lgl <- function() { - - x <- rbinom(10, 1, 0.5) > 0 - px <- rep(c(3, 2, 1), length.out = 10) - - set.seed(123); s1 <- sample_lgl(x, 6) - set.seed(123); s2 <- sample(x, 6) - - checkEquals( - s1, s2, - "sample_lgl / without replacement / without probability" - ) - - set.seed(123); s1 <- sample_lgl(x, 6, TRUE) - set.seed(123); s2 <- sample(x, 6, TRUE) - - checkEquals( - s1, s2, - "sample_lgl / with replacement / without probability" - ) - - set.seed(123); s1 <- sample_lgl(x, 6, FALSE, px) - set.seed(123); s2 <- sample(x, 6, FALSE, px) - - checkEquals( - s1, s2, - "sample_lgl / without replacement / with probability" - ) - - set.seed(123); s1 <- sample_lgl(x, 6, TRUE, px) - set.seed(123); s2 <- sample(x, 6, TRUE, px) - - checkEquals( - s1, s2, - "sample_lgl / with replacement / with probability" - ) - - } - - - ## sample_list tests - test.sugar.sample_list <- function() { - - x <- list( - letters, - 1:5, - rnorm(10), - state.abb, - state.area, - state.center, - matrix(1:9, 3), - mtcars, - AirPassengers, - BJsales - ) - px <- rep(c(3, 2, 1), length.out = 10) - - set.seed(123); s1 <- sample_list(x, 6) - set.seed(123); s2 <- sample(x, 6) - - checkEquals( - s1, s2, - "sample_list / without replacement / without probability" - ) - - set.seed(123); s1 <- sample_list(x, 6, TRUE) - set.seed(123); s2 <- sample(x, 6, TRUE) - - checkEquals( - s1, s2, - "sample_list / with replacement / without probability" - ) - - set.seed(123); s1 <- sample_list(x, 6, FALSE, px) - set.seed(123); s2 <- sample(x, 6, FALSE, px) - - checkEquals( - s1, s2, - "sample_list / without replacement / with probability" - ) - - set.seed(123); s1 <- sample_list(x, 6, TRUE, px) - set.seed(123); s2 <- sample(x, 6, TRUE, px) - - checkEquals( - s1, s2, - "sample_list / with replacement / with probability" - ) - - } - - - ## 31 January 2017 - ## upper_tri tests - test.sugar.upper_tri <- function() { - - x <- matrix(rnorm(9), 3) - - checkEquals( - UpperTri(x), upper.tri(x), - "upper_tri / symmetric / diag = FALSE" - ) - - checkEquals( - UpperTri(x, TRUE), upper.tri(x, TRUE), - "upper_tri / symmetric / diag = TRUE" - ) - - x <- matrix(rnorm(12), 3) - - checkEquals( - UpperTri(x), upper.tri(x), - "upper_tri / [3 x 4] / diag = FALSE" - ) - - checkEquals( - UpperTri(x, TRUE), upper.tri(x, TRUE), - "upper_tri / [3 x 4] / diag = TRUE" - ) - - x <- matrix(rnorm(12), 4) - - checkEquals( - UpperTri(x), upper.tri(x), - "upper_tri / [4 x 3] / diag = FALSE" - ) - - checkEquals( - UpperTri(x, TRUE), upper.tri(x, TRUE), - "upper_tri / [4 x 3] / diag = TRUE" - ) - - } - - - ## lower_tri tests - test.sugar.lower_tri <- function() { - - x <- matrix(rnorm(9), 3) - - checkEquals( - LowerTri(x), lower.tri(x), - "lower_tri / symmetric / diag = FALSE" - ) - - checkEquals( - LowerTri(x, TRUE), lower.tri(x, TRUE), - "lower_tri / symmetric / diag = TRUE" - ) - - x <- matrix(rnorm(12), 3) - - checkEquals( - LowerTri(x), lower.tri(x), - "lower_tri / [3 x 4] / diag = FALSE" - ) - - checkEquals( - LowerTri(x, TRUE), lower.tri(x, TRUE), - "lower_tri / [3 x 4] / diag = TRUE" - ) - - x <- matrix(rnorm(12), 4) - - checkEquals( - LowerTri(x), lower.tri(x), - "lower_tri / [4 x 3] / diag = FALSE" - ) - - checkEquals( - LowerTri(x, TRUE), lower.tri(x, TRUE), - "lower_tri / [4 x 3] / diag = TRUE" - ) - - } - - - ## 22 April 2017 - ## trimws -- vector - test.sugar.vtrimws <- function() { - - x <- c( - " a b c", "a b c ", " a b c ", - "\t\ta b c", "a b c\t\t", "\t\ta b c\t\t", - "\r\ra b c", "a b c\r\r", "\r\ra b c\r\r", - "\n\na b c", "a b c\n\n", "\n\na b c\n\n", - NA, "", " ", " \t\r\n ", "\n \t \r " - ) - - checkEquals( - vtrimws(x), trimws(x), - "vtrimws / which = 'both'" - ) - - checkEquals( - vtrimws(x, 'l'), trimws(x, 'l'), - "vtrimws / which = 'left'" - ) - - checkEquals( - vtrimws(x, 'r'), trimws(x, 'r'), - "vtrimws / which = 'right'" - ) - - checkException( - vtrimws(x, "invalid"), - msg = "vtrimws -- bad `which` argument" - ) - - } - - - ## trimws -- matrix - test.sugar.mtrimws <- function() { - - x <- c( - " a b c", "a b c ", " a b c ", - "\t\ta b c", "a b c\t\t", "\t\ta b c\t\t", - "\r\ra b c", "a b c\r\r", "\r\ra b c\r\r", - "\n\na b c", "a b c\n\n", "\n\na b c\n\n", - NA, "", " ", " \t\r\n ", "\n \t \r " - ) - x <- matrix(x, nrow = length(x), ncol = 4) - - checkEquals( - mtrimws(x), trimws(x), - "mtrimws / which = 'both'" - ) - - checkEquals( - mtrimws(x, 'l'), trimws(x, 'l'), - "mtrimws / which = 'left'" - ) - - checkEquals( - mtrimws(x, 'r'), trimws(x, 'r'), - "mtrimws / which = 'right'" - ) - - checkException( - mtrimws(x, "invalid"), - msg = "mtrimws -- bad `which` argument" - ) - - } - - - ## trimws -- String - test.sugar.strimws <- function() { - - x <- c( - " a b c", "a b c ", " a b c ", - "\t\ta b c", "a b c\t\t", "\t\ta b c\t\t", - "\r\ra b c", "a b c\r\r", "\r\ra b c\r\r", - "\n\na b c", "a b c\n\n", "\n\na b c\n\n", - NA, "", " ", " \t\r\n ", "\n \t \r " - ) - - lhs <- vapply( - x, strimws, character(1), - USE.NAMES = FALSE - ) - rhs <- vapply( - x, trimws, character(1), - USE.NAMES = FALSE - ) - - checkEquals( - lhs, rhs, - "strimws / which = 'both'" - ) - - lhs <- vapply( - x, strimws, character(1), - which = 'l', USE.NAMES = FALSE - ) - rhs <- vapply( - x, trimws, character(1), - which = 'l', USE.NAMES = FALSE - ) - - checkEquals( - lhs, rhs, - "strimws / which = 'left'" - ) - - lhs <- vapply( - x, strimws, character(1), - which = 'r', USE.NAMES = FALSE - ) - rhs <- vapply( - x, trimws, character(1), - which = 'r', USE.NAMES = FALSE - ) - - checkEquals( - lhs, rhs, - "strimws / which = 'right'" - ) - - checkException( - strimws(x[1], "invalid"), - msg = "strimws -- bad `which` argument" - ) - - } - - ## 21 July 2018 - ## min/max - test.sugar.min.max <- function() { - # min(empty) gives NA for integer, Inf for numeric (#844) - checkTrue(is.na(intmin(integer(0))), "min(integer(0))") - checkEquals(doublemin(numeric(0)), Inf, "min(numeric(0))") - - # max(empty_ gives NA for integer, Inf for numeric (#844) - checkTrue(is.na(intmax(integer(0))), "max(integer(0))") - checkEquals(doublemax(numeric(0)), -Inf, "max(numeric(0))") - - # 'normal' values - checkEquals(intmin(c(1:10)), 1L, "min(integer(...))") - checkEquals(doublemin(1.0*c(1:10)), 1.0, "min(numeric(...))") - checkEquals(intmax(c(1:10)), 10L, "min(integer(...))") - checkEquals(doublemax(1.0*c(1:10)), 10.0, "min(numeric(...))") - } -} diff --git a/inst/unitTests/runit.sugar.var.R b/inst/unitTests/runit.sugar.var.R deleted file mode 100644 index 66c8e900f..000000000 --- a/inst/unitTests/runit.sugar.var.R +++ /dev/null @@ -1,43 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; ess-indent-level: 4; indent-tabs-mode: nil; -*- -# -# Copyright (C) 2015 Wush Wu -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - test.Sugar.var <- function() { - fNumeric <- Rcpp::cppFunction('double myVar(NumericVector x) { return(var(x)); }') - fInteger <- Rcpp::cppFunction('double myVar(IntegerVector x) { return(var(x)); }') - fComplex <- Rcpp::cppFunction('double myVar(ComplexVector x) { return(var(x)); }') - fLogical <- Rcpp::cppFunction('double myVar(LogicalVector x) { return(var(x)); }') - test_data_real <- 1:10 - checkEquals(fNumeric(test_data_real * 1.1), var(test_data_real * 1.1)) - checkEquals(fInteger(test_data_real), var(test_data_real)) - test_data_complex_1 <- complex(real = 5:1, imag = 2:6) - test_data_complex_2 <- complex(real = 1:5, imag = 6:10) - test_data_complex_1_known_var <- 5 - test_data_complex_2_known_var <- 5 - checkEquals(fComplex(test_data_complex_1), test_data_complex_1_known_var) - checkEquals(fComplex(test_data_complex_2), test_data_complex_2_known_var) - test_data_logical <- c(TRUE, FALSE, TRUE, FALSE, TRUE) - checkEquals(fLogical(test_data_logical), var(test_data_logical)) - } - -} diff --git a/inst/unitTests/runit.support.R b/inst/unitTests/runit.support.R deleted file mode 100644 index 0e6fb5ee3..000000000 --- a/inst/unitTests/runit.support.R +++ /dev/null @@ -1,61 +0,0 @@ -#!/usr/bin/env r -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("support.cpp") - - test.plus.REALSXP <- function(){ - checkEquals( - plus_REALSXP(), - list(NA_real_,NA_real_,NA_real_) , - msg = " REALSXP + REALSXP" ) - } - - test.times.REALSXP <- function(){ - checkEquals( - times_REALSXP(), - list(NA_real_,NA_real_,NA_real_) , - msg = " REALSXP * REALSXP" ) - } - - test.divides.REALSXP <- function(){ - checkEquals( - divides_REALSXP(), - list(NA_real_,NA_real_,NA_real_) , - msg = " REALSXP / REALSXP" ) - } - - test.minus.REALSXP <- function(){ - checkEquals( - minus_REALSXP(), - list(NA_real_,NA_real_,NA_real_) , - msg = " REALSXP - REALSXP" ) - } - - test.functions.REALSXP <- function(){ - checkEquals( - functions_REALSXP(), - list( rep(NA_real_, 20L), rep(NA_real_, 6L) ) , - msg = "function(NA_REAL)" ) - } - -} diff --git a/inst/unitTests/runit.system.R b/inst/unitTests/runit.system.R deleted file mode 100644 index 8ec46ab2f..000000000 --- a/inst/unitTests/runit.system.R +++ /dev/null @@ -1,45 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2016 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - test.Rcpp.system.file <- function() { - inc_rcpp <- Rcpp:::Rcpp.system.file("include") - inc_sys <- tools::file_path_as_absolute( base::system.file("include", package = "Rcpp")) - checkEquals(inc_rcpp, inc_sys, msg = "Rcpp.system.file") - - } - - test.RcppLd <- function() { - checkTrue(Rcpp:::RcppLdPath() == "", msg = "RcppLdPath") - checkTrue(Rcpp:::RcppLdFlags() == "", msg = "RcppLdFlags") - checkEquals(Rcpp:::LdFlags(), NULL, msg = "LdFlags") - } - - test.RcppCxx <- function() { - checkTrue(Rcpp:::canUseCXX0X(), msg = "canUseCXX0X") - checkTrue(Rcpp:::RcppCxxFlags() != "", msg = "RcppCxxFlags()") - checkEquals(Rcpp:::CxxFlags(), NULL, msg = "CxxFlags()") - - checkTrue(length(Rcpp:::RcppCapabilities()) >= 13, msg = "RcppCapabilities()") - } -} diff --git a/inst/unitTests/runit.table.R b/inst/unitTests/runit.table.R deleted file mode 100644 index 07388c0d2..000000000 --- a/inst/unitTests/runit.table.R +++ /dev/null @@ -1,48 +0,0 @@ -#!/usr/bin/env r -# -# Copyright (C) 2014 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("table.cpp") - - table_ <- function(x) c(base::table(x, useNA="ifany")) - - test.table.numeric <- function() { - x <- c(1, 2, 1, 1, NA, NaN, -Inf, Inf) - checkEquals( RcppTable(x), table_(x), "table matches R: numeric case") - } - - test.table.integer <- function() { - x <- c(-1L, 1L, NA_integer_, NA_integer_, 100L, 1L) - checkEquals( RcppTable(x), table_(x), "table matches R: integer case") - } - - test.table.logical <- function() { - x <- c(TRUE, TRUE, FALSE, NA) - checkEquals( RcppTable(x), table_(x), "table matches R: logical case") - } - - test.table.character <- function() { - x <- c("a", "a", "b", "a", NA, NA) - checkEquals( RcppTable(x), table_(x), "table matches R: character case") - } - -} diff --git a/inst/unitTests/runit.wrap.R b/inst/unitTests/runit.wrap.R deleted file mode 100644 index 9b16fcad9..000000000 --- a/inst/unitTests/runit.wrap.R +++ /dev/null @@ -1,203 +0,0 @@ -#!/usr/bin/env r -# -# 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if (.runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("wrap.cpp") - - test.wrap.map.string.int <- function(){ - checkEquals(map_string_int(), - c( a = 200L, b = 100L, c = 300L), - msg = "wrap( map) " ) - } - - test.wrap.map.string.double <- function(){ - checkEquals(map_string_double(), - c( a = 200, b = 100, c = 300), - msg = "wrap( map) " ) - } - - test.wrap.map.string.bool <- function(){ - checkEquals(map_string_bool(), - c( a = FALSE, b = TRUE, c = TRUE ), - msg = "wrap( map) " ) - } - - test.wrap.map.string.Rbyte <- function(){ - checkEquals(map_string_Rbyte(), - c( a = as.raw(1), b = as.raw(0), c = as.raw(2) ), - msg = "wrap( map) " ) - } - - test.wrap.map.string.string <- function(){ - checkEquals(map_string_string(), - c( a = "bar", b = "foo", c = "bling" ), - msg = "wrap( map) " ) - } - - test.wrap.map.string.generic <- function(){ - checkEquals(map_string_generic(), - list( a = c(1L, 2L, 2L), b = c(1L, 2L), c = c(1L,2L,2L,2L) ) , - msg = "wrap( map>) " ) - } - - test.wrap.multimap.string.int <- function(){ - checkEquals(multimap_string_int(), - c( a = 200L, b = 100L, c = 300L), - msg = "wrap( multimap) ") - } - - test.wrap.multimap.string.double <- function(){ - checkEquals(multimap_string_double(), - c( a = 200, b = 100, c = 300), - msg = "wrap( multimap) " ) - } - - test.wrap.multimap.string.bool <- function(){ - checkEquals(multimap_string_bool(), - c( a = FALSE, b = TRUE, c = TRUE ), - msg = "wrap( multimap)") - } - - test.wrap.multimap.string.Rbyte <- function(){ - checkEquals(multimap_string_Rbyte(), - c( a = as.raw(1), b = as.raw(0), c = as.raw(2) ), - msg = "wrap( multimap) " ) - } - - test.wrap.multimap.string.string <- function(){ - checkEquals(multimap_string_string(), - c( a = "bar", b = "foo", c = "bling" ), - msg = "wrap( multimap) " ) - } - - test.wrap.multimap.string.generic <- function(){ - checkEquals(multimap_string_generic(), - list( a = c(1L, 2L, 2L), b = c(1L, 2L), c = c(1L,2L,2L,2L) ) , - msg = "wrap( multimap>) " ) - } - - test.nonnull.const.char <- function() { - checkEquals(nonnull_const_char(), - "foo", - msg = "null const char*") - } - - test.wrap.unordered.map.string.int <- function(){ - res <- unordered_map_string_int() - checkEquals( res[["a"]], 200L, msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["b"]], 100L, msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["c"]], 300L, msg = "wrap( tr1::unordered_map) " ) - } - - test.wrap.unordered.map.rcpp.string.int <- function(){ - res <- unordered_map_rcpp_string_int(c("a", "b", "c")) - checkEquals( res[["a"]], 200L, msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["b"]], 100L, msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["c"]], 300L, msg = "wrap( tr1::unordered_map) " ) - } - - test.unordered.set.rcpp.string <- function(){ - checkEquals(unordered_set_rcpp_string(c("a", "b", "c", "b")), - c(FALSE, FALSE, FALSE, TRUE), msg = "wrap( tr1::unordered_set) " ) - } - - test.wrap.unordered.map.string.double <- function(){ - res <- unordered_map_string_double() - checkEquals( res[["a"]], 200, msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["b"]], 100, msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["c"]], 300, msg = "wrap( tr1::unordered_map) " ) - } - - test.wrap.unordered.map.string.bool <- function(){ - res <- unordered_map_string_bool() - checkEquals( res[["a"]], FALSE, msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["b"]], TRUE , msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["c"]], TRUE , msg = "wrap( tr1::unordered_map) " ) - } - - test.wrap.unordered.map.string.Rbyte <- function(){ - res <- unordered_map_string_Rbyte() - checkEquals( res[["a"]], as.raw(1), msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["b"]], as.raw(0), msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["c"]], as.raw(2), msg = "wrap( tr1::unordered_map) " ) - } - - test.wrap.unordered.map.string.string <- function(){ - res <- unordered_map_string_string() - checkEquals( res[["a"]], "bar" , msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["b"]], "foo" , msg = "wrap( tr1::unordered_map) " ) - checkEquals( res[["c"]], "bling" , msg = "wrap( tr1::unordered_map) " ) - } - - test.wrap.unordered.map.string.generic <- function(){ - res <- unordered_map_string_generic() - checkEquals( res[["a"]], c(1L,2L,2L) , msg = "wrap( tr1::unordered_map>) " ) - checkEquals( res[["b"]], c(1L,2L) , msg = "wrap( tr1::unordered_map>) " ) - checkEquals( res[["c"]], c(1L,2L,2L,2L) , msg = "wrap( tr1::unordered_map>) " ) - } - - test.wrap.map.int.double <- function(){ - checkEquals( - map_int_double(), - c("-1" = 3, "0" = 2 ), - msg = "std::map" - ) - } - - test.wrap.map.double.double <- function(){ - checkEquals( - map_double_double(), - c("0" = 2, "1.2" = 3 ), - msg = "std::map" - ) - } - - test.wrap.map.int.vector_double <- function(){ - checkEquals( - map_int_vector_double(), - list("0" = c(1,2), "1" = c(2,3) ), - msg = "std::map >" - ) - } - - test.wrap.map.int.Foo <- function(){ - checkEquals( - sapply( map_int_Foo(), function(.) .$get() ), - c("0" = 2, "1" = 3 ), - msg = "std::map" - ) - } - - test.wrap.vector.Foo <- function(){ - checkEquals( - sapply( vector_Foo(), function(.) .$get() ), - c(2, 3), - msg = "std::vector< MODULE EXPOSED CLASS >" - ) - } - - test.wrap.custom.class <- function() { - checkEquals(test_wrap_custom_class(), 42) - } - -} - diff --git a/inst/unitTests/runit.wstring.R b/inst/unitTests/runit.wstring.R deleted file mode 100644 index 65dfd6a14..000000000 --- a/inst/unitTests/runit.wstring.R +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/env r -# -*- mode: R; tab-width: 4; -*- -# -# Copyright (C) 2013 - 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 . - -.runThisTest <- Sys.getenv("RunAllRcppTests") == "yes" - -if ( .runThisTest) { - - .setUp <- Rcpp:::unitTestSetup("wstring.cpp") - - test.CharacterVector_wstring <- function(){ - res <- CharacterVector_wstring() - checkEquals( res, c("foobar", "foobar" ) ) - } - - test.wstring_return <- function(){ - checkEquals( wstring_return(), "foo" ) - } - - test.wstring_param <- function(){ - checkEquals( wstring_param( "foo", "bar" ), "foobar" ) - } - - test.wrap_vector_wstring <- function(){ - checkEquals( wrap_vector_wstring( ), c("foo", "bar" ) ) - } - - ##test.as_vector_wstring <- function(){ - ## ## the "€" did not survive on Windows, so trying its unicode equivalent - ## checkEquals( as_vector_wstring(letters), paste0( letters, "\u20ac" ) ) - ##} - -} diff --git a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0.orig.tar.gz b/inst/unitTests/src/r-cran-testrcpppackage_0.1.0.orig.tar.gz deleted file mode 100644 index f412e2006..000000000 Binary files a/inst/unitTests/src/r-cran-testrcpppackage_0.1.0.orig.tar.gz and /dev/null differ diff --git a/inst/unitTests/testRcppInterfaceUser/src/config.h b/inst/unitTests/testRcppInterfaceUser/src/config.h deleted file mode 100644 index e69de29bb..000000000 diff --git a/inst/README b/local/README similarity index 100% rename from inst/README rename to local/README diff --git a/inst/THANKS b/local/THANKS similarity index 100% rename from inst/THANKS rename to local/THANKS 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.Rd b/man/Rcpp-package.Rd index 73f668d02..26206402b 100644 --- a/man/Rcpp-package.Rd +++ b/man/Rcpp-package.Rd @@ -8,9 +8,9 @@ the \code{.Call} interface provided by \R. } \section{Introduction}{ - \pkg{Rcpp} provides C++ classes to facilitate manipulation of a large - number of R data structures : vectors, functions, environments, ... - + \pkg{Rcpp} provides C++ classes to facilitate manipulation of a large + number of R data structures : vectors, functions, environments, ... + The \dQuote{Rcpp-introduction} vignette gives an introduction on the package } \section{Usage for package building}{ @@ -20,7 +20,7 @@ \references{ Dirk Eddelbuettel and Romain Francois (2011). \pkg{Rcpp}: Seamless R and C++ Integration. \emph{Journal of Statistical Software}, - \bold{40(8)}, 1-18. URL \url{http://www.jstatsoft.org/v40/i08/} and + \bold{40(8)}, 1-18, \doi{10.18637/jss.v040.i08}. Also available as \code{vignette("Rcpp-introduction")}. Eddelbuettel, Dirk (2013) Seamless R and C++ Integration with @@ -29,25 +29,25 @@ \section{History}{ The initial versions of Rcpp were written by Dominick Samperi during 2005 and 2006. - - Dirk Eddelbuettel made some additions, and became maintainer in 2008. - + + Dirk Eddelbuettel made some additions, and became maintainer in 2008. + Dirk Eddelbuettel and Romain Francois have been extending Rcpp since 2009. } \seealso{ Development for \pkg{Rcpp} can be followed via the GitHub repository - at \url{http://github.com/RcppCore/Rcpp}. + at \url{https://github.com/RcppCore/Rcpp}. Extensive examples with full documentation are available at - \url{http://gallery.rcpp.org}. + \url{https://gallery.rcpp.org}. } \examples{ -\dontrun{ +\dontrun{ # introduction to Rcpp -vignette("Rcpp-introduction") +vignette("Rcpp-introduction") # information on how to build a package that uses Rcpp -vignette("Rcpp-package") +vignette("Rcpp-package") } } \keyword{programming} 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/RcppLdFlags.Rd b/man/RcppLdFlags.Rd index 3abc642a0..6d90cbde2 100644 --- a/man/RcppLdFlags.Rd +++ b/man/RcppLdFlags.Rd @@ -20,7 +20,7 @@ \references{ Dirk Eddelbuettel and Romain Francois (2011). \pkg{Rcpp}: Seamless R and C++ Integration. \emph{Journal of Statistical Software}, - \bold{40(8)}, 1-18. URL http://www.jstatsoft.org/v40/i08/ and + \bold{40(8)}, 1-18, \doi{10.18637/jss.v040.i08}. Also available as \code{vignette("Rcpp-introduction")}. } \author{Dirk Eddelbuettel and Romain Francois} 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/cppFunction.Rd b/man/cppFunction.Rd index 4876c7583..a2401c361 100644 --- a/man/cppFunction.Rd +++ b/man/cppFunction.Rd @@ -8,8 +8,8 @@ Dynamically define an R function with C++ source code. Compiles and links a shar } \usage{ cppFunction(code, depends = character(), plugins = character(), includes = character(), - env = parent.frame(), rebuild = FALSE, cacheDir = getOption("rcpp.cache.dir", - tempdir()), showOutput = verbose, verbose = getOption("verbose")) + env = parent.frame(), rebuild = FALSE, cacheDir = getOption("rcpp.cache.dir", + tempdir()), showOutput = verbose, verbose = getOption("verbose"), echo = TRUE) } \arguments{ @@ -39,11 +39,14 @@ cppFunction(code, depends = character(), plugins = character(), includes = chara } \item{verbose}{ \code{TRUE} to print detailed information about generated code to the console. +} + \item{echo}{ + \code{TRUE} to silence output from optional R evaluation if set to \code{FALSE}. } } \details{ Functions defined using \code{cppFunction} must have return types that are compatible with \code{Rcpp::wrap} and parameter types that are compatible with \code{Rcpp::as}. - + The shared library will not be rebuilt if the underlying code has not changed since the last compilation. } \value{ @@ -63,36 +66,36 @@ cppFunction(code, depends = character(), plugins = character(), includes = chara cppFunction( 'int fibonacci(const int x) { - if (x == 0) return(0); + if (x == 0) return(0); if (x == 1) return(1); return (fibonacci(x - 1)) + fibonacci(x - 2); }') cppFunction(depends = "RcppArmadillo", 'List fastLm(NumericVector yr, NumericMatrix Xr) { - + int n = Xr.nrow(), k = Xr.ncol(); - - arma::mat X(Xr.begin(), n, k, false); + + arma::mat X(Xr.begin(), n, k, false); arma::colvec y(yr.begin(), yr.size(), false); - + arma::colvec coef = arma::solve(X, y); arma::colvec resid = y - X*coef; - + double sig2 = arma::as_scalar(arma::trans(resid)*resid/(n-k) ); arma::colvec stderrest = arma::sqrt( sig2 * arma::diagvec(arma::inv(arma::trans(X)*X))); - + return List::create(Named("coefficients") = coef, Named("stderr") = stderrest ); }') - + cppFunction(plugins=c("cpp11"), ' int useCpp11() { auto x = 10; return x; }') - + } } diff --git a/man/dependsAttribute.Rd b/man/dependsAttribute.Rd index 304408b75..55073052e 100644 --- a/man/dependsAttribute.Rd +++ b/man/dependsAttribute.Rd @@ -17,14 +17,14 @@ The \code{Rcpp::depends} attribute is added to a C++ source file to indicate tha } \details{ - The \code{Rcpp::depends} attribute is used by the implementation of the \code{\link{sourceCpp}} function to correctly setup the build environment for \code{R CMD SHLIB}. - + The \code{Rcpp::depends} attribute is used by the implementation of the \code{\link{sourceCpp}} function to correctly setup the build environment for \code{R CMD SHLIB}. + The include directories of the specified packages are added to the \code{CLINK_CPPFLAGS} environment variable. In addition, if the referenced package provides an \link[inline:plugins]{inline plugin} it is called to determine additional environment variables required to successfully build. } \note{ - The \code{Rcpp::depends} attribute is specified using a syntax compatible with the new \href{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}{generalized attributes} feature of the C++11 standard. Note however that since this feature is not yet broadly supported by compilers it needs to be specified within a comment (see examples below). + The \code{Rcpp::depends} attribute is specified using a syntax compatible with the new \href{https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}{generalized attributes} feature of the C++11 standard. Note however that since this feature is not yet broadly supported by compilers it needs to be specified within a comment (see examples below). } @@ -40,4 +40,3 @@ The \code{Rcpp::depends} attribute is added to a C++ source file to indicate tha // [[Rcpp::depends(Matrix, RcppGSL)]] } } - 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/exportAttribute.Rd b/man/exportAttribute.Rd index 65900eeaf..532c3c1c6 100644 --- a/man/exportAttribute.Rd +++ b/man/exportAttribute.Rd @@ -21,10 +21,10 @@ The \code{Rcpp::export} attribute is added to a C++ function definition to indic \item Use fully qualified type names for the return value and all parameters. However, Rcpp types may appear without the namespace qualifier (i.e. \code{DataFrame} is okay as a type name but \code{std::string} must be specified fully). } If default argument values are provided in the C++ function definition then these defaults are also used for the exported R function. For example, the following C++ function: - + \preformatted{ DataFrame readData( - CharacterVector file, + CharacterVector file, CharacterVector exclude = CharacterVector::create(), bool fill = true) } @@ -41,8 +41,8 @@ function (file, exclude = character(0), fill = TRUE) \note{ When a C++ function has export bindings automatically generated by the \code{\link{compileAttributes}} function, it can optionally also have a direct C++ interface generated using the \code{\link[=interfacesAttribute]{Rcpp::interfaces}} attribute. - - The \code{Rcpp::export} attribute is specified using a syntax compatible with the new \href{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}{generalized attributes} feature of the C++11 standard. Note however that since this feature is not yet broadly supported by compilers it needs to be specified within a comment (see examples below). + +o The \code{Rcpp::export} attribute is specified using a syntax compatible with the new \href{https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}{generalized attributes} feature of the C++11 standard. Note however that since this feature is not yet broadly supported by compilers it needs to be specified within a comment (see examples below). } \seealso{ @@ -61,7 +61,7 @@ int fibonacci(const int x) { if (x == 0) return(0); if (x == 1) return(1); - + return (fibonacci(x - 1)) + fibonacci(x - 2); } @@ -71,11 +71,11 @@ NumericVector convolve(NumericVector a, NumericVector b) { int na = a.size(), nb = b.size(); int nab = na + nb - 1; NumericVector xab(nab); - + for (int i = 0; i < na; i++) for (int j = 0; j < nb; j++) xab[i + j] += a[i] * b[j]; - + return xab; } } diff --git a/man/getRcppVersion.Rd b/man/getRcppVersion.Rd new file mode 100644 index 000000000..97d39780c --- /dev/null +++ b/man/getRcppVersion.Rd @@ -0,0 +1,38 @@ +% Generated by roxygen2: do not edit by hand +% Please edit documentation in R/tools.R +\name{getRcppVersion} +\alias{getRcppVersion} +\title{Export the Rcpp (API) Package Version} +\usage{ +getRcppVersion(devel = FALSE) +} +\arguments{ +\item{devel}{An logical value indicating if the development or +release version number should be returned, default is release.} +} +\value{ +A \code{package_version} object with either the release +or development version. +} +\description{ +Helper function to report the package version of the R installation. +} +\details{ +While \code{packageVersion(Rcpp)} exports the version registers in +\code{DESCRIPTION}, this version does get incremented more easily +during development and can therefore be higher than the released +version. The actual \code{#define} long used at the C++ level +corresponds more to an \sQuote{API Version} which is now provided +by this function, and use for example in the package skeleton +generator. +} +\examples{ +getRcppVersion() +} +\seealso{ +\code{\link{packageVersion}}, +\code{\link{Rcpp.package.skeleton}} +} +\author{ +Dirk Eddelbuettel +} diff --git a/man/interfacesAttribute.Rd b/man/interfacesAttribute.Rd index 8afc7efd6..3911daf5c 100644 --- a/man/interfacesAttribute.Rd +++ b/man/interfacesAttribute.Rd @@ -17,14 +17,14 @@ The \code{Rcpp::interfaces} attribute is added to a C++ source file to specify w } \details{ - The \code{Rcpp::interfaces} attribute is used to determine which bindings to generate for exported functions. The default behavior if no \code{Rcpp::interfaces} attribute is specified is to generate only an R interface. - + The \code{Rcpp::interfaces} attribute is used to determine which bindings to generate for exported functions. The default behavior if no \code{Rcpp::interfaces} attribute is specified is to generate only an R interface. + When \code{cpp} bindings are requested code is generated as follows: \enumerate{ \item Bindings are generated into a header file located in the \code{inst/include} directory of the package using the naming convention \emph{PackageName_RcppExports.h} - \item If not already present, an additional header file named \emph{PackageName.h} is also generated which in turn includes the Rcpp exports header. - + \item If not already present, an additional header file named \emph{PackageName.h} is also generated which in turn includes the Rcpp exports header. + In the case that you already have a \emph{PackageName.h} header for your package then you can manually add an include of the Rcpp exports header to it to make the exported functions available to users of your package. \item The generated header file allows calling the exported C++ functions without any linking dependency on the package (this is based on using the \code{R_RegisterCCallable} and \code{R_GetCCallable} functions). \item The exported functions are defined within a C++ namespace that matches the name of the package. @@ -41,17 +41,17 @@ For example, an exported C++ function \code{foo} could be called from package \c } } - The above example assumes that the \code{sourceCpp} function will be used to compile the code. If rather than that you are building a package then you don't need to include the \code{Rcpp::depends} attribute, but instead should add an entry for the referenced package in the \code{Depends} and \code{LinkingTo} fields of your package's \code{DESCRIPTION} file. + The above example assumes that the \code{sourceCpp} function will be used to compile the code. If rather than that you are building a package then you don't need to include the \code{Rcpp::depends} attribute, but instead should add an entry for the referenced package in the \code{Depends} and \code{LinkingTo} fields of your package's \code{DESCRIPTION} file. } \note{ If a file by the name of \emph{PackageName.h} that wasn't generated by \code{compileAttributes} already exists in in the \code{inst/include} directory then it will not be overwritten (rather, an error will occur). - + A static naming scheme for generated header files and namespaces is used to ensure consistent usage semantics for clients of exported \code{cpp} interfaces. Packages that wish to export more complex interfaces or additional C++ types are therefore typically better off not using this mechanism. - The \code{Rcpp::interfaces} attribute is specified using a syntax compatible with the new \href{http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}{generalized attributes} feature of the C++11 standard. Note however that since this feature is not yet broadly supported by compilers it needs to be specified within a comment (see examples below). + The \code{Rcpp::interfaces} attribute is specified using a syntax compatible with the new \href{https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}{generalized attributes} feature of the C++11 standard. Note however that since this feature is not yet broadly supported by compilers it needs to be specified within a comment (see examples below). } @@ -65,4 +65,3 @@ For example, an exported C++ function \code{foo} could be called from package \c // [[Rcpp::interfaces(r, cpp)]] } } - 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/man/sourceCpp.Rd b/man/sourceCpp.Rd index 7f0b14de0..bcbfcfc32 100644 --- a/man/sourceCpp.Rd +++ b/man/sourceCpp.Rd @@ -8,16 +8,17 @@ Source C++ Code from a File or String and RCPP_MODULE declarations. A shared library is then built and its exported functions and Rcpp modules are made available in the specified environment. } \usage{ -sourceCpp(file = "", code = NULL, env = globalenv(), embeddedR = TRUE, rebuild = FALSE, +sourceCpp(file = "", code = NULL, env = globalenv(), embeddedR = TRUE, rebuild = FALSE, cacheDir = getOption("rcpp.cache.dir", tempdir()), cleanupCacheDir = FALSE, - showOutput = verbose, verbose = getOption("verbose"), dryRun = FALSE) + showOutput = verbose, verbose = getOption("verbose"), dryRun = FALSE, + windowsDebugDLL = FALSE, echo = TRUE) } \arguments{ \item{file}{ A character string giving the path name of a file } \item{code}{ - A character string with source code. If supplied, the code is taken from this string instead of a file. + A character string with source code. If supplied, the code is taken from this string instead of a file. } \item{env}{ Environment where the R functions and modules should be made available. @@ -43,30 +44,36 @@ sourceCpp(file = "", code = NULL, env = globalenv(), embeddedR = TRUE, rebuild = \item{dryRun}{ \code{TRUE} to do a dry run (showing commands that would be used rather than actually executing the commands). +} + \item{windowsDebugDLL}{ + \code{TRUE} to create a debug DLL on Windows (and ignored on other platforms). +} + \item{echo}{ + \code{TRUE} to silence output from optional R evaluation if set to \code{FALSE}. } } \details{ If the \code{code} parameter is provided then the \code{file} parameter is ignored. - Functions exported using \code{sourceCpp} must meet several conditions, - including being defined in the global namespace and having return types - that are compatible with \code{Rcpp::wrap} and parameter types that are - compatible with \code{Rcpp::as}. + Functions exported using \code{sourceCpp} must meet several conditions, + including being defined in the global namespace and having return types + that are compatible with \code{Rcpp::wrap} and parameter types that are + compatible with \code{Rcpp::as}. See the \code{\link[=exportAttribute]{Rcpp::export}} documentation for more details. - - Content of Rcpp Modules will be automatically loaded into the specified - environment using the \code{\link[=Module]{Module}} and - \code{\link[=populate]{populate}} functions. - - If the source file has compilation dependencies on other - packages (e.g. \pkg{Matrix}, \pkg{RcppArmadillo}) then an - \code{\link[=dependsAttribute]{Rcpp::depends}} attribute - should be provided naming these dependencies. - - It's possible to embed chunks of R code within a C++ source file by - including the R code within a block comment with the + + Content of Rcpp Modules will be automatically loaded into the specified + environment using the \code{\link[=Module]{Module}} and + \code{\link[=populate]{populate}} functions. + + If the source file has compilation dependencies on other + packages (e.g. \pkg{Matrix}, \pkg{RcppArmadillo}) then an + \code{\link[=dependsAttribute]{Rcpp::depends}} attribute + should be provided naming these dependencies. + + It's possible to embed chunks of R code within a C++ source file by + including the R code within a block comment with the prefix of \code{/*** R}. For example: - + \preformatted{ /*** R @@ -76,11 +83,11 @@ fibonacci(10) */ } - Multiple R code chunks can be included in a C++ file. R code is sourced after the C++ compilation is completed so all functions and modules will be available to the R code. + Multiple R code chunks can be included in a C++ file. R code is sourced after the C++ compilation is completed so all functions and modules will be available to the R code. } \value{ - Returns (invisibly) a list with two elements: + Returns (invisibly) a list with two elements: \tabular{ll}{ \code{functions} \tab Names of exported functions\cr \code{modules} \tab Names of Rcpp modules\cr @@ -91,9 +98,9 @@ fibonacci(10) The \code{sourceCpp} function will not rebuild the shared library if the source file has not changed since the last compilation. The \code{sourceCpp} function is designed for compiling a standalone source file whose only dependencies are R packages. If you are compiling more than one source file or have external dependencies then you should create an R package rather than using \code{sourceCpp}. Note that the \code{\link[=exportAttribute]{Rcpp::export}} attribute can also be used within packages via the \code{\link{compileAttributes}} function. - + If you are sourcing a C++ file from within the \code{src} directory of a package then the package's \code{LinkingTo} dependencies, \code{inst/include}, and \code{src} directories are automatically included in the compilation. - + If no \code{Rcpp::export} attributes or \code{RCPP_MODULE} declarations are found within the source file then a warning is printed to the console. You can disable this warning by setting the \code{rcpp.warnNoExports} option to \code{FALSE}. } diff --git a/src/api.cpp b/src/api.cpp index 6273d49e4..723a90ccc 100644 --- a/src/api.cpp +++ b/src/api.cpp @@ -2,7 +2,8 @@ // // api.cpp: Rcpp R/C++ interface class library -- Rcpp api // -// Copyright (C) 2012 - 2016 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2020 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 - 2025 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -20,48 +21,31 @@ // along with Rcpp. If not, see . #define COMPILING_RCPP +#define RCPP_USE_GLOBAL_ROSTREAM #include using namespace Rcpp; #include "internal.h" -#include #ifdef RCPP_HAS_DEMANGLING #include #endif -#if defined(__GNUC__) || defined(__clang__) - #if defined(_WIN32) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__sun) || defined(_AIX) || defined(__MUSL__) || defined(__HAIKU__) || defined(__ANDROID__) - // do nothing - #else - #include - - // Extract mangled name e.g. ./test(baz+0x14)[0x400962] - static std::string demangler_one(const char* input) { - static std::string buffer; - buffer = input; - size_t last_open = buffer.find_last_of('('); - size_t last_close = buffer.find_last_of(')'); - if (last_open == std::string::npos || - last_close == std::string::npos) { - return input; // #nocov - } - std::string function_name = buffer.substr(last_open + 1, last_close - last_open - 1); - // Strip the +0x14 (if it exists, which it does not in earlier versions of gcc) - size_t function_plus = function_name.find_last_of('+'); - if (function_plus != std::string::npos) { - function_name.resize(function_plus); - } - buffer.replace(last_open + 1, function_name.size(), demangle(function_name)); - return buffer; - } - #endif -#endif - - namespace Rcpp { + // [[Rcpp::register]] + Rostream& Rcpp_cout_get() { + static Rostream Rcpp_cout; + return Rcpp_cout; + } + // [[Rcpp::register]] + Rostream& Rcpp_cerr_get() { + static Rostream Rcpp_cerr; + return Rcpp_cerr; + } + Rostream& Rcout = Rcpp_cout_get(); + Rostream& Rcerr = Rcpp_cerr_get(); namespace internal { @@ -82,7 +66,7 @@ namespace Rcpp { } // [[Rcpp::register]] - unsigned long beginSuspendRNGSynchronization() { + unsigned long beginSuspendRNGSynchronization() { // #nocov start ++rngSynchronizationSuspended; return rngSynchronizationSuspended; } @@ -91,7 +75,7 @@ namespace Rcpp { unsigned long endSuspendRNGSynchronization() { --rngSynchronizationSuspended; return rngSynchronizationSuspended; - } + } // #nocov end // [[Rcpp::register]] char* get_string_buffer() { @@ -102,36 +86,40 @@ namespace Rcpp { } // [[Rcpp::register]] - const char * type2name(SEXP x) { // #nocov start + const char * type2name(SEXP x) { // #nocov start switch (TYPEOF(x)) { - case NILSXP: return "NILSXP"; - case SYMSXP: return "SYMSXP"; - case RAWSXP: return "RAWSXP"; - case LISTSXP: return "LISTSXP"; - case CLOSXP: return "CLOSXP"; - case ENVSXP: return "ENVSXP"; - case PROMSXP: return "PROMSXP"; - case LANGSXP: return "LANGSXP"; - case SPECIALSXP: return "SPECIALSXP"; - case BUILTINSXP: return "BUILTINSXP"; - case CHARSXP: return "CHARSXP"; - case LGLSXP: return "LGLSXP"; - case INTSXP: return "INTSXP"; - case REALSXP: return "REALSXP"; - case CPLXSXP: return "CPLXSXP"; - case STRSXP: return "STRSXP"; - case DOTSXP: return "DOTSXP"; - case ANYSXP: return "ANYSXP"; - case VECSXP: return "VECSXP"; - case EXPRSXP: return "EXPRSXP"; - case BCODESXP: return "BCODESXP"; - case EXTPTRSXP: return "EXTPTRSXP"; - case WEAKREFSXP: return "WEAKREFSXP"; - case S4SXP: return "S4SXP"; + case NILSXP: return "NILSXP"; + case SYMSXP: return "SYMSXP"; + case RAWSXP: return "RAWSXP"; + case LISTSXP: return "LISTSXP"; + case CLOSXP: return "CLOSXP"; + case ENVSXP: return "ENVSXP"; + case PROMSXP: return "PROMSXP"; + case LANGSXP: return "LANGSXP"; + case SPECIALSXP: return "SPECIALSXP"; + case BUILTINSXP: return "BUILTINSXP"; + case CHARSXP: return "CHARSXP"; + case LGLSXP: return "LGLSXP"; + case INTSXP: return "INTSXP"; + case REALSXP: return "REALSXP"; + case CPLXSXP: return "CPLXSXP"; + case STRSXP: return "STRSXP"; + case DOTSXP: return "DOTSXP"; + case ANYSXP: return "ANYSXP"; + case VECSXP: return "VECSXP"; + case EXPRSXP: return "EXPRSXP"; + case BCODESXP: return "BCODESXP"; + case EXTPTRSXP: return "EXTPTRSXP"; + case WEAKREFSXP: return "WEAKREFSXP"; +#if R_VERSION >= R_Version(4,4,0) // replaces S4SXP in R 4.4.0 + case OBJSXP: return Rf_isS4(x) ? "S4SXP" : "OBJSXP"; // cf src/main/inspect.c +#else + case S4SXP: return "S4SXP"; +#endif default: return ""; } - } // #nocov end + } // #nocov end } // namespace Rcpp @@ -155,53 +143,39 @@ std::string demangle(const std::string& name) { #endif } +// NOTE: remains registered but this routine is now effectively unused by Rcpp; +// we retain it for backwards compatibility with any existing packages which +// (explicitly or implicitly) rely on its existence. See also: +// https://github.com/RcppCore/Rcpp/issues/1066 + // [[Rcpp::register]] -const char* short_file_name(const char* file) { // #nocov start - std::string f(file); +const char* short_file_name(const char* file) { // #nocov start + static std::string f; + f = file; size_t index = f.find("/include/"); if (index != std::string::npos) { f = f.substr(index + 9); } return f.c_str(); -} // #nocov end +} // [[Rcpp::internal]] -SEXP as_character_externalptr(SEXP xp) { // #nocov start +SEXP as_character_externalptr(SEXP xp) { char buffer[20]; - snprintf(buffer, 20, "%p", (void*)EXTPTR_PTR(xp)); + snprintf(buffer, 20, "%p", (void*)R_ExternalPtrAddr(xp)); return Rcpp::wrap((const char*)buffer); -} // #nocov end +} // #nocov end // [[Rcpp::internal]] 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; @@ -209,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; @@ -261,62 +215,21 @@ 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 -} // #nocov end +SEXP rcpp_can_use_cxx0x() { // #nocov start + return Rf_ScalarLogical(TRUE); +} // [[Rcpp::internal]] -SEXP rcpp_can_use_cxx11() { // #nocov start - #if defined(RCPP_USING_CXX11) - return Rf_ScalarLogical(TRUE); - #else - return Rf_ScalarLogical(FALSE); - #endif -} // #nocov end - +SEXP rcpp_can_use_cxx11() { + return Rf_ScalarLogical(TRUE); +} // [[Rcpp::register]] SEXP stack_trace(const char* file, int line) { - #if defined(__GNUC__) || defined(__clang__) - #if defined(_WIN32) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__sun) || defined(_AIX) || defined(__MUSL__) || defined(__HAIKU__) || defined(__ANDROID__) - // Simpler version for Windows and *BSD - List trace = List::create(_["file"] = file, - _[ "line" ] = line, - _[ "stack" ] = "C++ stack not available on this system"); - trace.attr("class") = "Rcpp_stack_trace"; - return trace; - #else // ! (defined(_WIN32) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__CYGWIN__) || defined(__sun) || defined(_AIX) || defined(__ANDROID__) - - /* inspired from http://tombarta.wordpress.com/2008/08/01/c-stack-traces-with-gcc/ */ - const size_t max_depth = 100; - int stack_depth; - void *stack_addrs[max_depth]; - char **stack_strings; - - stack_depth = backtrace(stack_addrs, max_depth); - stack_strings = backtrace_symbols(stack_addrs, stack_depth); - - std::string current_line; - - CharacterVector res(stack_depth - 1); - std::transform(stack_strings + 1, stack_strings + stack_depth, res.begin(), demangler_one); - free(stack_strings); // malloc()ed by backtrace_symbols - - List trace = List::create(_["file" ] = file, - _["line" ] = line, - _["stack"] = res); - trace.attr("class") = "Rcpp_stack_trace"; - return trace; - #endif - #else /* !defined( __GNUC__ ) */ - return R_NilValue; - #endif -} + return R_NilValue; +} // #nocov end + // // [ [ Rcpp::register ] ] // void print(SEXP s) { @@ -325,3 +238,11 @@ SEXP stack_trace(const char* file, int line) { // }}} + +// [[Rcpp::internal]] +SEXP getRcppVersionStrings() { + Shield versionstring(Rf_allocVector(STRSXP,2)); + SET_STRING_ELT(versionstring, 0, Rf_mkChar(RCPP_VERSION_STRING)); + SET_STRING_ELT(versionstring, 1, Rf_mkChar(RCPP_DEV_VERSION_STRING)); + return versionstring; +} diff --git a/src/attributes.cpp b/src/attributes.cpp index 94a23424e..641b13624 100644 --- a/src/attributes.cpp +++ b/src/attributes.cpp @@ -1,8 +1,7 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// // attributes.cpp: Rcpp R/C++ interface class library -- Rcpp attributes // -// Copyright (C) 2012 - 2017 JJ Allaire, Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2012 - 2020 JJ Allaire, Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 - 2026 JJ Allaire, Dirk Eddelbuettel, Romain Francois, Iñaki Ucar and Travers Ching // // This file is part of Rcpp. // @@ -32,6 +31,7 @@ #include #include #include +#include // for std::endl #include #include @@ -153,6 +153,8 @@ namespace attributes { const char * const kExportAttribute = "export"; const char * const kExportName = "name"; const char * const kExportRng = "rng"; + const char * const kExportInvisible = "invisible"; + const char * const kExportSignature = "signature"; const char * const kInitAttribute = "init"; const char * const kDependsAttribute = "depends"; const char * const kPluginsAttribute = "plugins"; @@ -163,11 +165,13 @@ namespace attributes { const char * const kParamValueTrue = "true"; const char * const kParamValueFALSE = "FALSE"; const char * const kParamValueTRUE = "TRUE"; + const char * const kParamBlockStart = "{;"; + const char * const kParamBlockEnd = "}"; // Type info class Type { public: - Type() {} + Type(): isConst_(false), isReference_(false) {} Type(const std::string& name, bool isConst, bool isReference) : name_(name), isConst_(isConst), isReference_(isReference) { @@ -381,8 +385,31 @@ namespace attributes { return true; } + bool invisible() const { + Param invisibleParam = paramNamed(kExportInvisible); + if (!invisibleParam.empty()) + return invisibleParam.value() == kParamValueTrue || // #nocov + invisibleParam.value() == kParamValueTRUE; // #nocov + else + return false; + } + const std::vector& roxygen() const { return roxygen_; } + std::string customRSignature() const { + Param sigParam = paramNamed(kExportSignature); + std::string sig = sigParam.value(); + trimWhitespace(&sig); + if (sig.empty()) return sig; + if (sig.back() == '}') + sig = sig.substr(0, sig.size()-1); + // check sig.empty again since we deleted an element + if (sig.empty()) return sig; + if (sig.front() == '{') + sig.erase(0,1); + return sig; + } + private: std::string name_; std::vector params_; @@ -624,6 +651,9 @@ namespace attributes { // if it wasn't (throws exception on io error) bool commit(const std::string& preamble = std::string()); + // Convert a dot in package name to underscore for use in header file name + std::string dotNameHelper(const std::string & name) const; + private: // Private virtual for doWriteFunctions so the base class @@ -708,7 +738,7 @@ namespace attributes { std::string includeDir_; }; - // Class which manages generating PackageName_RcppExports.h header file + // Class which manages generating PackageName.h header file class CppPackageIncludeGenerator : public ExportsGenerator { public: CppPackageIncludeGenerator(const std::string& packageDir, @@ -783,6 +813,10 @@ namespace attributes { std::string generateRArgList(const Function& function); + bool checkRSignature(const Function& function, std::string args); + + void initializeGlobals(std::ostream& ostr); + void generateCpp(std::ostream& ostr, const SourceFileAttributes& attributes, bool includePrototype, @@ -909,7 +943,7 @@ namespace attributes { for (size_t i = 0; i( + std::string file = Rcpp::as( // #nocov filePathSansExt(include)) + exts[i]; exists = fileExists(file); @@ -947,7 +981,7 @@ namespace attributes { parseSourceDependencies(sourceFile, &dependencies); // remove main source file - dependencies.erase(std::remove(dependencies.begin(), + dependencies.erase(std::remove(dependencies.begin(), // #nocov dependencies.end(), FileInfo(sourceFile)), dependencies.end()); @@ -1165,7 +1199,7 @@ namespace attributes { // Now read into a list of strings (which we can pass to regexec) // First read into a std::deque (which will handle lots of append - // operations efficiently) then copy into an R chracter vector + // operations efficiently) then copy into an R character vector std::deque lines; readLines(buffer, &lines); lines_ = Rcpp::wrap(lines); @@ -1253,9 +1287,9 @@ namespace attributes { // check for a match Rcpp::CharacterVector match = initMatches[i]; if (match.size() > 0) { - hasPackageInit_ = true; + hasPackageInit_ = true; // #nocov start break; - } + } // #nocov end } // Parse embedded R @@ -1275,9 +1309,9 @@ namespace attributes { SourceFileAttributesParser parser(dependency, packageName, false); // copy to base attributes (if it's a new attribute) - for (SourceFileAttributesParser::const_iterator + for (SourceFileAttributesParser::const_iterator // #nocov start it = parser.begin(); it != parser.end(); ++it) { - if (std::find(attributes_.begin(), // #nocov start + if (std::find(attributes_.begin(), attributes_.end(), *it) == attributes_.end()) { attributes_.push_back(*it); // #nocov end @@ -1297,7 +1331,6 @@ namespace attributes { Attribute SourceFileAttributesParser::parseAttribute( const std::vector& match, int lineNumber) { - // Attribute name std::string name = match[1]; @@ -1352,7 +1385,9 @@ namespace attributes { // parameter that isn't name or rng else if (!value.empty() && (name != kExportName) && - (name != kExportRng)) { + (name != kExportRng) && + (name != kExportInvisible) && + (name != kExportSignature)) { rcppExportWarning("Unrecognized parameter '" + name + "'", lineNumber); } @@ -1363,6 +1398,16 @@ namespace attributes { value != kParamValueFALSE && value != kParamValueTRUE) { rcppExportWarning("rng value must be true or false", + lineNumber); + } + } + // invisible that isn't true of false + else if (name == kExportInvisible) { + if (value != kParamValueFalse && + value != kParamValueTrue && + value != kParamValueFALSE && + value != kParamValueTRUE) { + rcppExportWarning("invisible value must be true or false", lineNumber); // #nocov end } } @@ -1396,22 +1441,41 @@ namespace attributes { // Parse attribute parameters std::vector SourceFileAttributesParser::parseParameters( const std::string& input) { + std::string::size_type blockstart = input.find_first_of(kParamBlockStart); + std::string::size_type blockend = input.find_last_of(kParamBlockEnd); const std::string delimiters(","); - std::vector params; std::string::size_type current; - std::string::size_type next = -1; + std::string::size_type next = std::string::npos; + std::string::size_type signature_param_start = std::string::npos; do { // #nocov next = input.find_first_not_of(delimiters, next + 1); if (next == std::string::npos) break; // #nocov - next -= 1; - current = next + 1; - next = input.find_first_of(delimiters, current); + current = next; + do { + next = input.find_first_of(delimiters, next + 1); + } while((next >= blockstart) && (next <= blockend) && + (next != std::string::npos)); params.push_back(Param(input.substr(current, next - current))); + if(params.back().name() == kExportSignature) { + signature_param_start = current; + } } while(next != std::string::npos); + // if the signature param was found, then check that the name, + // start block and end block exist and are in the correct order + if(signature_param_start != std::string::npos) { + bool sigchecks = + signature_param_start < blockstart && + blockstart < blockend && + blockstart != std::string::npos && + blockend != std::string::npos; + if(!sigchecks) { + throw Rcpp::exception("signature parameter found but missing {}"); + } + } return params; } @@ -1433,8 +1497,8 @@ namespace attributes { beginParenLoc == std::string::npos || endParenLoc < beginParenLoc) { - rcppExportNoFunctionFoundWarning(lineNumber); - return Function(); + rcppExportNoFunctionFoundWarning(lineNumber); // #nocov + return Function(); // #nocov } // Find the type and name by scanning backwards for the whitespace that @@ -1489,7 +1553,7 @@ namespace attributes { trimWhitespace(&arg); if (arg.empty()) { // we don't warn here because the compilation will fail anyway - continue; + continue; // #nocov } // If the argument has an = within it then it has a default value @@ -1550,7 +1614,7 @@ namespace attributes { // Look for the signature termination ({ or ; not inside quotes) // on this line and then subsequent lines if necessary std::string signature; - for (int i = lineNumber; i args; - char prevChar = 0; - for (std::string::const_iterator - it = argText.begin(); it != argText.end(); ++it) { - char ch = *it; + char quote = 0; + bool escaped = false; + typedef std::string::const_iterator it_t; + for (it_t it = argText.begin(); it != argText.end(); ++it) { - if (ch == '"' && prevChar != '\\') { - insideQuotes = !insideQuotes; - } + // Store current character + char ch = *it; - if ((ch == ',') && + // Ignore quoted strings and character values in single quotes + if ( ! quote && (ch == '"' || ch == '\'')) + quote = ch; + else if (quote && ch == quote && ! escaped) + quote = 0; + + // Escaped character inside quotes + if (escaped) + escaped = false; + else if (quote && ch == '\\') + escaped = true; + + // Detect end of argument declaration + if ( ! quote && + (ch == ',') && (templateCount == 0) && - (parenCount == 0) && - !insideQuotes) { + (parenCount == 0)) { args.push_back(currentArg); currentArg.clear(); continue; - } else { + } + + // Append current character if not a space at start + if ( ! currentArg.empty() || ch != ' ') currentArg.push_back(ch); + + // Count use of potentially enclosed brackets + if ( ! quote) { switch(ch) { case '<': templateCount++; @@ -1618,16 +1699,14 @@ namespace attributes { case '>': templateCount--; break; - case '(': - parenCount++; // #nocov - break; // #nocov + case '(': // #nocov start + parenCount++; + break; case ')': - parenCount--; // #nocov - break; // #nocov + parenCount--; + break; // #nocov end } } - - prevChar = ch; } if (!currentArg.empty()) @@ -1859,6 +1938,13 @@ namespace attributes { return removeFile(targetFile_); } + // Convert a possible dot in package name to underscore as needed for header file + std::string ExportsGenerator::dotNameHelper(const std::string & name) const { + std::string newname(name); + std::replace(newname.begin(), newname.end(), '.', '_'); + return newname; + } + CppExportsGenerator::CppExportsGenerator(const std::string& packageDir, const std::string& package, const std::string& fileSep) @@ -2082,6 +2168,8 @@ namespace attributes { // always bring in Rcpp ostr << "using namespace Rcpp;" << std::endl << std::endl; + // initialize references to global Rostreams + initializeGlobals(ostr); // commit with preamble return ExportsGenerator::commit(ostr.str()); @@ -2093,7 +2181,7 @@ namespace attributes { const std::string& fileSep) : ExportsGenerator( packageDir + fileSep + "inst" + fileSep + "include" + - fileSep + package + kRcppExportsSuffix, + fileSep + dotNameHelper(package) + kRcppExportsSuffix, package, "//") { @@ -2311,7 +2399,7 @@ namespace attributes { const std::string& fileSep) : ExportsGenerator( packageDir + fileSep + "inst" + fileSep + "include" + - fileSep + package + ".h", + fileSep + dotNameHelper(package) + ".h", package, "//") { @@ -2324,7 +2412,6 @@ namespace attributes { std::string guard = getHeaderGuard(); // #nocov start ostr() << "#ifndef " << guard << std::endl; ostr() << "#define " << guard << std::endl << std::endl; - ostr() << "#include \"" << packageCpp() << kRcppExportsSuffix << "\"" << std::endl; @@ -2394,24 +2481,34 @@ namespace attributes { // build the parameter list std::string args = generateRArgList(function); - + // check if has a custom signature + if(attribute.hasParameter(kExportSignature)) { + args = attribute.customRSignature(); + if(!checkRSignature(function, args)) { + std::string rsig_err_msg = "Missing args in " + args; // #nocov + throw Rcpp::exception(rsig_err_msg.c_str()); // #nocov + } + } // determine the function name std::string name = attribute.exportedName(); + // determine if return invisible + bool isInvisibleOrVoid = function.type().isVoid() || attribute.invisible(); + // write the function ostr() << name << " <- function(" << args << ") {" << std::endl; ostr() << " "; - if (function.type().isVoid()) + if (isInvisibleOrVoid) ostr() << "invisible("; // #nocov ostr() << ".Call("; if (!registration_) - ostr() << "'"; + ostr() << "'"; // #nocov else ostr() << "`"; ostr() << packageCppPrefix() << "_" << function.name(); if (!registration_) - ostr() << "', " << "PACKAGE = '" << package() << "'"; + ostr() << "', " << "PACKAGE = '" << package() << "'"; // #nocov else ostr() << "`"; @@ -2420,7 +2517,7 @@ namespace attributes { for (size_t i = 0; i required_args; + const std::vector& arguments = function.arguments(); + for (size_t i = 0; i parsed_args = + Rcpp::as >(pargs_cv); + + for(size_t i=0; i& Rcpp::Rcout = Rcpp::Rcpp_cout_get();"; + ostr << std::endl; + ostr << "Rcpp::Rostream& Rcpp::Rcerr = Rcpp::Rcpp_cerr_get();"; + ostr << std::endl; + ostr << "#endif" << std::endl << std::endl; + } + // Generate the C++ code required to make [[Rcpp::export]] functions // available as C symbols with SEXP parameters and return void generateCpp(std::ostream& ostr, @@ -2813,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(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 @@ -2933,7 +3074,7 @@ namespace attributes { // skip empty case if (pStr->empty()) - return; + return; // #nocov // trim right std::string::size_type pos = pStr->find_last_not_of(kWhitespaceChars); @@ -3131,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); @@ -3141,6 +3282,8 @@ namespace { // always include Rcpp.h in case the user didn't ostr << std::endl << std::endl; ostr << "#include " << std::endl; + // initialize references to global Rostreams + initializeGlobals(ostr); generateCpp(ostr, sourceAttributes, true, false, contextId_); generatedCpp_ = ostr.str(); std::ofstream cppOfs(generatedCppSourcePath().c_str(), @@ -3289,10 +3432,22 @@ namespace { continue; const Function& function = attribute.function(); + // build the parameter list + std::string args = generateRArgList(function); + + // check if has a custom signature + 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()); + } + } + // export the function ostr << attribute.exportedName() << " <- Rcpp:::sourceCppFunction(" - << "function(" << generateRArgList(function) << ") {}, " + << "function(" << args << ") {}, " << (function.type().isVoid() ? "TRUE" : "FALSE") << ", " << dllInfo << ", " << "'" << contextId_ + "_" + function.name() @@ -3533,14 +3688,14 @@ BEGIN_RCPP // don't process RcppExports.cpp std::string cppFile = cppFiles[i]; if (endsWith(cppFile, "RcppExports.cpp")) - continue; + continue; // #nocov // parse file SourceFileAttributesParser attributes(cppFile, packageName, false); // note if we found a package init function if (!hasPackageInit && attributes.hasPackageInit()) - hasPackageInit = true; + hasPackageInit = true; // #nocov // continue if no generator output if (!attributes.hasGeneratorOutput()) @@ -3579,7 +3734,7 @@ BEGIN_RCPP depends.begin(), depends.end(), std::back_inserter(diff)); if (!diff.empty()) { - std::string msg = + std::string msg = // #nocov start "The following packages are referenced using Rcpp::depends " "attributes however are not listed in the Depends, Imports or " "LinkingTo fields of the package DESCRIPTION file: "; @@ -3594,11 +3749,10 @@ BEGIN_RCPP // verbose output if (verbose) { for (size_t i=0; i >(updated); END_RCPP } - diff --git a/src/barrier.cpp b/src/barrier.cpp index 51a81dbbf..aa0febb68 100644 --- a/src/barrier.cpp +++ b/src/barrier.cpp @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; tab-width: 4 -*- -// + // barrier.cpp: Rcpp R/C++ interface class library -- write barrier // -// Copyright (C) 2010 - 2015 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2020 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 - 2026 Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -22,14 +22,18 @@ #define COMPILING_RCPP #define USE_RINTERNALS + +#include #include + #include -#include "internal.h" -#include #include +#include + +#include "internal.h" // [[Rcpp::register]] -SEXP get_string_elt(SEXP x, R_xlen_t i) { +SEXP get_string_elt(SEXP x, R_xlen_t i) { // #nocov start return STRING_ELT(x, i); } @@ -50,7 +54,8 @@ void char_set_string_elt(SEXP x, R_xlen_t i, const char* value) { // [[Rcpp::register]] SEXP* get_string_ptr(SEXP x) { - return STRING_PTR(x); + // TODO: should we deprecate this? + return const_cast(RCPP_STRING_PTR(x)); } // [[Rcpp::register]] @@ -65,12 +70,14 @@ void set_vector_elt(SEXP x, R_xlen_t i, SEXP value) { // [[Rcpp::register]] SEXP* get_vector_ptr(SEXP x) { - return VECTOR_PTR(x); + // TODO: should we deprecate this? + return const_cast(RCPP_VECTOR_PTR(x)); // #nocov end } // [[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]] @@ -88,6 +95,47 @@ static SEXP Rcpp_cache = R_NilValue; #define RCPP_HASH_CACHE_INITIAL_SIZE 1024 #endif +namespace Rcpp { +static SEXP Rcpp_precious = R_NilValue; +// [[Rcpp::register]] +void Rcpp_precious_init() { + Rcpp_precious = CONS(R_NilValue, R_NilValue); // set up + R_PreserveObject(Rcpp_precious); // and protect +} +// [[Rcpp::register]] +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; // #nocov + } + PROTECT(object); + SEXP cell = PROTECT(CONS(Rcpp_precious, CDR(Rcpp_precious))); + SET_TAG(cell, object); + SETCDR(Rcpp_precious, cell); + if (CDR(cell) != R_NilValue) { + SETCAR(CDR(cell), cell); + } + UNPROTECT(2); + return cell; +} +// [[Rcpp::register]] +void Rcpp_precious_remove(SEXP token) { + if (token == R_NilValue || TYPEOF(token) != LISTSXP) { + return; + } + SET_TAG(token, R_NilValue); + SEXP before = CAR(token); + SEXP after = CDR(token); + SETCDR(before, after); + if (after != R_NilValue) { + SETCAR(after, before); + } +} +} + // only used for debugging SEXP get_rcpp_cache() { if (! Rcpp_cache_know) { @@ -97,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; @@ -153,7 +205,7 @@ SEXP init_Rcpp_cache() { } // [[Rcpp::register]] -SEXP reset_current_error() { +SEXP reset_current_error() { // #nocov start SEXP cache = get_rcpp_cache(); // error occured @@ -189,7 +241,7 @@ SEXP rcpp_error_recorder(SEXP e) { // [[Rcpp::register]] SEXP rcpp_get_current_error() { - return VECTOR_ELT(get_rcpp_cache(), 2); + return VECTOR_ELT(get_rcpp_cache(), 2); // #nocov end } // [[Rcpp::register]] @@ -206,4 +258,3 @@ int* get_cache(int m) { std::fill(res, res+m, 0); return res; } - diff --git a/src/Date.cpp b/src/date.cpp similarity index 97% rename from src/Date.cpp rename to src/date.cpp index 2b9221c03..ae6f30fe6 100644 --- a/src/Date.cpp +++ b/src/date.cpp @@ -1,9 +1,6 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// jedit: :folding=explicit: -// // Date.cpp: Rcpp R/C++ interface class library -- Date type // -// Copyright (C) 2010 - 2016 Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2023 Dirk Eddelbuettel and Romain Francois // // The mktime00() as well as the gmtime_() replacement function are // Copyright (C) 2000 - 2010 The R Development Core Team. @@ -28,6 +25,7 @@ #define COMPILING_RCPP +#include // for TRUE,FALSE #include #include // for gmtime #include @@ -85,11 +83,11 @@ namespace Rcpp { year0 = year_base + tm.tm_year; /* safety check for unbounded loops */ if (year0 > 3000) { - excess = (int)(year0/2000) - 1; - year0 -= excess * 2000; + excess = (int)(year0/2000) - 1; // #nocov start + year0 -= (int)(excess * 2000); } else if (year0 < 0) { excess = -1 - (int)(-year0/2000); - year0 -= excess * 2000; + year0 -= (int)(excess * 2000); // #nocov end } for(i = 0; i < tm.tm_mon; i++) day += days_in_month[i]; @@ -451,7 +449,7 @@ struct tzhead { ** Normalize logic courtesy Paul Eggert. */ - static int increment_overflow(int *const ip, int j) { + static int increment_overflow(int *const ip, int j) { int const i = *ip; /* @@ -461,12 +459,12 @@ struct tzhead { ** or if j < INT_MIN - i; given i < 0, INT_MIN - i cannot overflow. */ if ((i >= 0) ? (j > INT_MAX - i) : (j < INT_MIN - i)) - return TRUE; + return TRUE; // #nocov *ip += j; return FALSE; } - static int increment_overflow_time(time_t *tp, int_fast32_t j) { + static int increment_overflow_time(time_t *tp, int_fast32_t j) { // #nocov start /* ** This is like ** 'if (! (time_t_min <= *tp + j && *tp + j <= time_t_max)) ...', @@ -480,7 +478,7 @@ struct tzhead { return FALSE; } - static int_fast32_t detzcode(const char *const codep) { // #nocov start + static int_fast32_t detzcode(const char *const codep) { int_fast32_t result = (codep[0] & 0x80) ? -1 : 0; for (int i = 0; i < 4; ++i) result = (result << 8) | (codep[i] & 0xff); @@ -629,7 +627,7 @@ struct tzhead { return strp; } - // this routine modified / simplified / reduced in 2010 + // this routine modified / simplified / reduced in 2010 static int tzload(const char * name, struct state * const sp, const int doextend) { const char * p; int i; @@ -702,7 +700,7 @@ struct tzhead { } } - nread = read(fid, u.buf, sizeof u.buf); + nread = (int)read(fid, u.buf, sizeof u.buf); if (close(fid) < 0 || nread <= 0) return -1; for (stored = 4; stored <= 8; stored *= 2) { @@ -852,7 +850,7 @@ struct tzhead { while (i < ts.timecnt && sp->timecnt < TZ_MAX_TIMES) { sp->ats[sp->timecnt] = ts.ats[i]; - sp->types[sp->timecnt] = sp->typecnt + ts.types[i]; + sp->types[sp->timecnt] = (unsigned char)sp->typecnt + ts.types[i]; ++sp->timecnt; ++i; } @@ -1218,7 +1216,7 @@ struct tzhead { &sp->chars[bp->tt_abbrind]) == 0; } return result; - } // #nocov end + } // #nocov end static int leaps_thru_end_of(const int y) { return (y >= 0) ? (y / 4 - y / 100 + y / 400) : @@ -1241,7 +1239,7 @@ struct tzhead { hit = 0; i = sp->leapcnt; while (--i >= 0) { - lp = &sp->lsis[i]; + lp = &sp->lsis[i]; // #nocov start if (*timep >= lp->ls_trans) { if (*timep == lp->ls_trans) { hit = ((i == 0 && lp->ls_corr > 0) || @@ -1257,7 +1255,7 @@ struct tzhead { } } corr = lp->ls_corr; - break; + break; // #nocov end } } y = EPOCH_YEAR; @@ -1272,13 +1270,13 @@ struct tzhead { tdelta = tdays / DAYSPERLYEAR; if (! ((! TYPE_SIGNED(time_t) || INT_MIN <= tdelta) && tdelta <= INT_MAX)) - return NULL; + return NULL; // #nocov idelta = (int)tdelta; if (idelta == 0) idelta = (tdays < 0) ? -1 : 1; newy = y; if (increment_overflow(&newy, idelta)) - return NULL; + return NULL; // #nocov leapdays = leaps_thru_end_of(newy - 1) - leaps_thru_end_of(y - 1); tdays -= ((time_t) newy - y) * DAYSPERNYEAR; @@ -1297,7 +1295,7 @@ struct tzhead { */ idays = (int)tdays; rem += offset - corr; - while (rem < 0) { + while (rem < 0) { // #nocov start rem += SECSPERDAY; --idays; } @@ -1313,14 +1311,14 @@ struct tzhead { while (idays >= year_lengths[isleap(y)]) { idays -= year_lengths[isleap(y)]; if (increment_overflow(&y, 1)) - return NULL; + return NULL; // #nocov end } // Previously we returned 'year + base', so keep behaviour // It seems like R now returns just 'year - 1900' (as libc does) - // But better for continuity to do as before + // But better for continuity to do as before tmp->tm_year = y + TM_YEAR_BASE; if (increment_overflow(&tmp->tm_year, -TM_YEAR_BASE)) - return NULL; + return NULL; // #nocov tmp->tm_yday = idays; /* ** The "extra" mods below avoid overflow problems. @@ -1333,7 +1331,7 @@ struct tzhead { idays; tmp->tm_wday %= DAYSPERWEEK; if (tmp->tm_wday < 0) - tmp->tm_wday += DAYSPERWEEK; + tmp->tm_wday += DAYSPERWEEK; // #nocov tmp->tm_hour = (int) (rem / SECSPERHOUR); rem %= SECSPERHOUR; tmp->tm_min = (int) (rem / SECSPERMIN); diff --git a/src/internal.h b/src/internal.h index 42362787a..45f6c1a01 100644 --- a/src/internal.h +++ b/src/internal.h @@ -128,6 +128,8 @@ CALLFUN_0(rcpp_capabilities); CALLFUN_0(rcpp_can_use_cxx0x); CALLFUN_0(rcpp_can_use_cxx11); +CALLFUN_0(getRcppVersionStrings); + /* .External functions */ EXTFUN(CppMethod__invoke); EXTFUN(CppMethod__invoke_void); diff --git a/src/Module.cpp b/src/module.cpp similarity index 99% rename from src/Module.cpp rename to src/module.cpp index d15bbff21..3ffb5639b 100644 --- a/src/Module.cpp +++ b/src/module.cpp @@ -53,7 +53,7 @@ RCPP_FUN_2(Rcpp::CppClass, Module__get_class, XP_Module module, std::string cl) return module->get_class(cl); } RCPP_FUN_1(bool, CppObject__needs_init, SEXP xp) { // #nocov start - return EXTPTR_PTR(xp) == 0; + return R_ExternalPtrAddr(xp) == 0; } RCPP_FUN_1(Rcpp::CharacterVector, CppClass__methods, XP_Class cl) { return cl->method_names(); diff --git a/src/Rcpp_init.cpp b/src/rcpp_init.cpp similarity index 81% rename from src/Rcpp_init.cpp rename to src/rcpp_init.cpp index d998a876c..da5943de0 100644 --- a/src/Rcpp_init.cpp +++ b/src/rcpp_init.cpp @@ -1,8 +1,8 @@ -// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*- -// + // Rcpp_init.cpp : Rcpp R/C++ interface class library -- Initialize and register // -// Copyright (C) 2010 - 2017 John Chambers, Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2010 - 2020 John Chambers, Dirk Eddelbuettel and Romain Francois +// Copyright (C) 2021 John Chambers, Dirk Eddelbuettel, Romain Francois and Iñaki Ucar // // This file is part of Rcpp. // @@ -57,6 +57,8 @@ static R_CallMethodDef callEntries[] = { CALLDEF(rcpp_capabilities,0), CALLDEF(rcpp_can_use_cxx0x,0), CALLDEF(rcpp_can_use_cxx11,0), + + CALLDEF(getRcppVersionStrings,0), {NULL, NULL, 0} }; @@ -119,22 +121,29 @@ void registerFunctions(){ RCPP_REGISTER(error_occured) RCPP_REGISTER(rcpp_get_current_error) // RCPP_REGISTER(print) + RCPP_REGISTER(Rcpp_precious_init) + RCPP_REGISTER(Rcpp_precious_teardown) + RCPP_REGISTER(Rcpp_precious_preserve) + RCPP_REGISTER(Rcpp_precious_remove) + RCPP_REGISTER(Rcpp_cout_get) + RCPP_REGISTER(Rcpp_cerr_get) #undef RCPP_REGISTER } - -extern "C" void R_unload_Rcpp(DllInfo *) { // #nocov start - // Release resources -} // #nocov end +extern "C" void R_unload_Rcpp(DllInfo *) { // #nocov start + Rcpp::Rcpp_precious_teardown(); // release resource +} // #nocov end extern "C" void R_init_Rcpp(DllInfo* dllinfo) { setCurrentScope(0); - registerFunctions(); // call wrapper to register export symbols + registerFunctions(); // call wrapper to register export symbols + + R_useDynamicSymbols(dllinfo, FALSE); // set up symbol symbol lookup (cf R 3.4.0) - R_useDynamicSymbols(dllinfo, FALSE); // set up symbol symbol lookup (cf R 3.4.0) + init_Rcpp_cache(); // init the cache - init_Rcpp_cache(); // init the cache + Rcpp::Rcpp_precious_init(); - init_Rcpp_routines(dllinfo); // init routines + init_Rcpp_routines(dllinfo); // init routines } diff --git a/tests/doRUnit.R b/tests/doRUnit.R deleted file mode 100644 index 4e48107b8..000000000 --- a/tests/doRUnit.R +++ /dev/null @@ -1,64 +0,0 @@ -# Copyright (C) 2009 - 2018 Dirk Eddelbuettel and Romain Francois -# Earlier copyrights Gregor Gorjanc, Martin Maechler and Murray Stokely as detailed below -# -# 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 . - -## doRUnit.R --- Run RUnit tests -## -## with credits to package fUtilities in RMetrics -## which credits Gregor Gojanc's example in CRAN package 'gdata' -## as per the R Wiki http://wiki.r-project.org/rwiki/doku.php?id=developers:runit -## and changed further by Martin Maechler -## and more changes by Murray Stokely in HistogramTools -## and then used adapted in RProtoBuf -## and now used here with two additional env var setters/getters -## -## Dirk Eddelbuettel, Feb 2014 - -if (requireNamespace("RUnit", quietly=TRUE) && - requireNamespace("Rcpp", quietly=TRUE)) { - - library(RUnit) - library(Rcpp) - - set.seed(42) # Set a seed to make the test deterministic - - ## Define tests - testSuite <- defineTestSuite(name = "Rcpp Unit Tests", - dirs = system.file("unitTests", package = "Rcpp"), - testFuncRegexp = "^[Tt]est.+") - - Sys.setenv("R_TESTS"="") # without this, we get (or used to get) unit test failures - - ## 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 release, and - if (Sys.getenv("RunAllRcppTests") != "no") { # if env.var not yet set - message("Setting \"RunAllRcppTests\"=\"yes\" for development release\n") - Sys.setenv("RunAllRcppTests"="yes") - } - } - - tests <- runTestSuite(testSuite) # Run tests - - printTextProtocol(tests) # Print results - - ## Return success or failure to R CMD CHECK - if (getErrors(tests)$nFail > 0) stop("TEST FAILED!") - if (getErrors(tests)$nErr > 0) stop("TEST HAD ERRORS!") - if (getErrors(tests)$nTestFunc < 1 && Sys.getenv("RunAllRcppTests")=="yes") - stop("NO TEST FUNCTIONS RUN!") -} diff --git a/tests/tinytest.R b/tests/tinytest.R new file mode 100644 index 000000000..61cc2b8a7 --- /dev/null +++ b/tests/tinytest.R @@ -0,0 +1,52 @@ + +if (requireNamespace("tinytest", quietly=TRUE)) { + + ## 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(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") + Sys.setenv("RunAllRcppTests"="yes") + } + if (Sys.getenv("RunVerboseRcppTests") != "no") { # if env.var not yet set + message("Setting \"RunVerboseRcppTests\"=\"yes\" for development release") + Sys.setenv("RunVerboseRcppTests"="yes") + } + } + + ## On Travis also always set tests; see + ## https://docs.travis-ci.com/user/environment-variables/#default-environment-variables + ## GitHub Action also set CI variable; see + ## https://docs.github.com/en/actions/reference/environment-variables + ## And we set it in 'docker run' call + ## Ensure Codecov runs full tests too + if ((Sys.getenv("CI") == "true") || + (Sys.getenv("TRAVIS") == "true") || + (Sys.getenv("CONTINUOUS_INTEGRATION") == "true") || + (Sys.getenv("CODECOV_TOKEN") != "")) { + if (Sys.getenv("RunAllRcppTests") != "no") { # if env.var not yet set + message("Always enabling \"RunAllRcppTests\"=\"yes\" in CI\n") + Sys.setenv("RunAllRcppTests"="yes") + } + if (Sys.getenv("RunVerboseRcppTests") != "no") { # if env.var not yet set + message("Always enabling \"RunVerboseRcppTests\"=\"yes\" in CI\n") + Sys.setenv("RunVerboseRcppTests"="yes") + } + } + + ## there are several more granular ways to test files in a tinytest directory, + ## see its package vignette; tests can also run once the package is installed + ## using the same command `test_package(pkgName)`, or by director or file + tinytest::test_package("Rcpp") +} diff --git a/vignettes/.gitignore b/vignettes/.gitignore index 603207a92..8fd6643ff 100644 --- a/vignettes/.gitignore +++ b/vignettes/.gitignore @@ -5,5 +5,9 @@ Rcpp-*.bbl Rcpp-*.blg Rcpp-*.log Rcpp-*.tex -Rcpp-*.pdf unitTests-results/ +rmd/figures/bootstrap.pdf +rmd/OLDbackup +rmd/*_cache +rmd/*.pdf +rmd/*.cls diff --git a/vignettes/Makefile b/vignettes/Makefile new file mode 100644 index 000000000..18568860c --- /dev/null +++ b/vignettes/Makefile @@ -0,0 +1,42 @@ + +## No GNUmake for R so replacing efficient wildcard ops with explicit enumeration +## Remove spaces between ': =' and '$ ( ... )' to re-activate + +##rnwsources : = $ ( wildcard *.Rnw ) +##rnwvignettes : = $ ( rnwsources:.Rnw=.pdf ) + +rnwsources = Rcpp-attributes.Rnw \ + Rcpp-extending.Rnw \ + Rcpp-FAQ.Rnw \ + Rcpp-introduction.Rnw \ + Rcpp-jss-2011.Rnw \ + Rcpp-libraries.Rnw \ + Rcpp-modules.Rnw \ + Rcpp-package.Rnw \ + Rcpp-quickref.Rnw \ + Rcpp-sugar.Rnw + +rnwvignettes = Rcpp-attributes.pdf \ + Rcpp-extending.pdf \ + Rcpp-FAQ.pdf \ + Rcpp-introduction.pdf \ + Rcpp-jss-2011.pdf \ + Rcpp-libraries.pdf \ + Rcpp-modules.pdf \ + Rcpp-package.pdf \ + Rcpp-quickref.pdf \ + Rcpp-sugar.pdf + +%.tex: %.Rnw + Rscript -e 'Sweave("$<")' + +%.pdf: %.tex + Rscript -e 'tools::texi2pdf("$<", texi2dvi="pdflatex")' + Rscript -e 'tools::texi2pdf("$<", texi2dvi="pdflatex")' + Rscript -e 'tools::compactPDF("$@", gs_quality="ebook")' + +all: ${rnwvignettes} + @rm -f *.aux *.log *.tex + +clean: + @rm -f *.aux *.log *.tex diff --git a/vignettes/Rcpp-FAQ.pdf b/vignettes/Rcpp-FAQ.pdf new file mode 100644 index 000000000..c2745605c Binary files /dev/null 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.pdf b/vignettes/Rcpp-attributes.pdf new file mode 100644 index 000000000..7eca2b952 Binary files /dev/null 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.pdf b/vignettes/Rcpp-extending.pdf new file mode 100644 index 000000000..1c85d3175 Binary files /dev/null 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.pdf b/vignettes/Rcpp-introduction.pdf new file mode 100644 index 000000000..268930ea9 Binary files /dev/null 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 new file mode 100644 index 000000000..eb0d3b057 Binary files /dev/null and b/vignettes/Rcpp-jss-2011.pdf differ diff --git a/vignettes/Rcpp-jss-2011.pdf.asis b/vignettes/Rcpp-jss-2011.pdf.asis new file mode 100644 index 000000000..d55537828 --- /dev/null +++ b/vignettes/Rcpp-jss-2011.pdf.asis @@ -0,0 +1,5 @@ +%\VignetteIndexEntry{Rcpp-JSS-2011} +%\VignetteKeywords{Rcpp, foreign function interface, .Call, C++, R} +%\VignettePackage{Rcpp} +%\VignetteEncoding{UTF-8} +%\VignetteEngine{Rcpp::asis} diff --git a/vignettes/Rcpp-libraries.pdf b/vignettes/Rcpp-libraries.pdf new file mode 100644 index 000000000..031023868 Binary files /dev/null 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.pdf b/vignettes/Rcpp-modules.pdf new file mode 100644 index 000000000..62b1c704e Binary files /dev/null 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.pdf b/vignettes/Rcpp-package.pdf new file mode 100644 index 000000000..aa2cf4e37 Binary files /dev/null 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.pdf b/vignettes/Rcpp-quickref.pdf new file mode 100644 index 000000000..ddca8d948 Binary files /dev/null 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.pdf b/vignettes/Rcpp-sugar.pdf new file mode 100644 index 000000000..6f61a6d53 Binary files /dev/null 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/figures/bootstrap.pdf b/vignettes/figures/bootstrap.pdf deleted file mode 100644 index 30ef1116a..000000000 Binary files a/vignettes/figures/bootstrap.pdf and /dev/null differ diff --git a/vignettes/getCurrentVersionsOfCitedPackages.R b/vignettes/getCurrentVersionsOfCitedPackages.R deleted file mode 100644 index 64b50a8f1..000000000 --- a/vignettes/getCurrentVersionsOfCitedPackages.R +++ /dev/null @@ -1,17 +0,0 @@ -#/usr/bin/r - -setwd("~/git/rcpp/vignettes") -cmd <- "grep package= Rcpp.bib | cut -c27- | sed -e 's/\"$//' | sort | uniq" -con <- pipe(cmd) -pkgs <- readLines(pipe(cmd)) -close(con) - -repo <- "https://cloud.r-project.org" -AP <- available.packages(contrib.url(repo),filter=list()) # available package at CRAN - -res <- as.data.frame(do.call(rbind, lapply(pkgs, function(p) { - ind <- which(AP[,"Package"] == p) - if (length(ind) > 1) ind <- ind[1] - AP[ind, c("Package", "Version")] -}))) -print(res) diff --git a/vignettes/.install_extras b/vignettes/rmd/.install_extras similarity index 100% rename from vignettes/.install_extras rename to vignettes/rmd/.install_extras diff --git a/vignettes/rmd/Makefile b/vignettes/rmd/Makefile new file mode 100644 index 000000000..4de500cf1 --- /dev/null +++ b/vignettes/rmd/Makefile @@ -0,0 +1,24 @@ + +## This Makefile is not included in the package sources so we can use GNUmake idioms. Yay. + +rmdsources := $(wildcard *.Rmd) +rmdvignettes := $(rmdsources:.Rmd=.pdf) + +%.pdf: %.Rmd + Rscript -e 'rmarkdown::render("$<")' + Rscript -e 'tools::compactPDF("$@", gs_quality="ebook")' + cp -vax $@ .. + +all: ${rmdvignettes} Rcpp-jss-2011.pdf + +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 + pdflatex Rcpp-jss-2011.tex + pdflatex Rcpp-jss-2011.tex + Rscript -e 'tools::compactPDF("$@", gs_quality="ebook")' + 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/Rcpp-FAQ.Rmd b/vignettes/rmd/Rcpp-FAQ.Rmd similarity index 78% rename from vignettes/Rcpp-FAQ.Rmd rename to vignettes/rmd/Rcpp-FAQ.Rmd index 6406841f8..5e7f01ded 100644 --- a/vignettes/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 @@ -61,7 +61,7 @@ bibliography: Rcpp #watermark: false # Customize footer, eg by referencing the vignette -footer_contents: "Rcpp Vignette" +footer_contents: "Rcpp FAQ Vignette" # Omit \pnasbreak at end skip_final_break: true @@ -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} @@ -88,7 +88,7 @@ vignette: > \tableofcontents ```{r setup, include=FALSE} -knitr::opts_chunk$set(cache=TRUE) +knitr::opts_chunk$set(cache=FALSE) library(Rcpp) library(inline) options("width"=50, digits=5) @@ -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,68 +131,61 @@ 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 +## What compiler can I use {#q:what-compiler} -On almost all platforms, the GNU Compiler Collection (or `gcc`, which -is also the name of its \proglang{C} language compiler) has to be used along -with the corresponding `g++` compiler for the \proglang{C++} language. -A minimal suitable version is a final 4.2.* release; earlier 4.2.* were -lacking some \proglang{C++} features (and even 4.2.1, still used on OS X as the -last gcc release), has issues). - -Generally speaking, the default compilers on all the common platforms are suitable. +On almost all platforms, the GNU Compiler Collection (or `gcc`, which is also +the name of its \proglang{C} language compiler) can be used along with the +corresponding `g++` compiler for the \proglang{C++} language. Depending on +which C++ compilation standard one wishes to use, a suitably recent variant +of the compiler may be needed. But these days the minimum standard of C++11 +is generally available, and the default compilers on all the common platforms +are now suitable. Specific per-platform notes: \begin{description} \item[Windows] users need the \texttt{Rtools} package from the site maintained by - Duncan Murdoch which contains all the required tools in a single package; - complete instructions specific to Windows are in the `R Administration' - manual \citep[Appendix D]{R:Administration}. As of August 2014, it still - installs the \texttt{gcc/g++} 4.6.* compiler which limits the ability to use - modern C++ standards so only \code{s-std=c++0x} is supported. R 3.1.0 and - above detect this and set appropriate flags. - \item[OS X] users, as noted in the `R Administration' manual \citep[Appendix + Tomas Kalibera which contains all the required tools in a single package; + complete instructions specific to Windows are in the "R Administration" + 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://itunes.apple.com/us/app/xcode/id497799835?mt=12}{Xcode} (OS X $\le 10.8$) or \href{https://developer.apple.com/library/ios/technotes/tn2339/_index.html}{Xcode Command Line Tools} (OS X $\ge 10.9$) (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. Depending on whether on OS X release before or after - Mavericks is used, different additional installation may be needed. Consult + \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} The `clang` and `clang++` compilers from the LLVM project can also be used. On Linux, they are inter-operable with `gcc` et al. On -OS X, they are unfortunately not ABI compatible. The `clang++` -compiler is interesting as it emits much more comprehensible error messages -than `g++` (though `g++` 4.8 and 4.9 have caught up). +macOS, they are unfortunately not ABI compatible. -The Intel `icc` family has also been used successfully as its output -files can also be combined with those from `gcc`. +In general, any compiler supported by R itself can be used. ## What other packages are useful -Additional packages that we have found useful are: +Additional packages that we have found useful are \pkg{inline} if one wants +to create compiled functions _without_ the help of \pkg{Rcpp} as well as the different benchmarking +and unit testing packages. A short list follows, it is not meant to be +exhaustive as CRAN by now has \textsl{many} helpful packages: \begin{description} \item[\pkg{inline}] which is invaluable for direct compilation, linking and loading of short code snippets---but now effectively superseded by the Rcpp Attributes (see \faq{using-attributes} and \faq{prototype-using-attributes}) feature provided by \pkg{Rcpp}; -\item[\pkg{RUnit}] is used for unit testing; the package is recommended and - will be needed to re-run some of our tests but it is not strictly required - during use of \pkg{Rcpp}; -\item[\pkg{rbenchmark}] to run simple timing comparisons and benchmarks; it is also - recommended but not required. -\item[\pkg{microbenchmark}] is an alternative for benchmarking. -\item[\pkg{devtools}] can help the process of building, compiling and testing - a package but it too is entirely optional. + \item[\pkg{RUnit}, \pkg{tinytest}, \pkg{testthat}] can be used for unit + 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 + comparisons and benchmarks; they are also recommended but not required. \end{description} ## What licenses can I choose for my code @@ -257,13 +250,10 @@ Template Library to sum the elements of a numeric vector. ```{r} fx <- cxxfunction(signature(x = "numeric"), - 'NumericVector xx(x); - return wrap( - std::accumulate(xx.begin(), - xx.end(), - 0.0) - );', - plugin = "Rcpp") + 'NumericVector xx(x); + return wrap(std::accumulate(xx.begin(), + xx.end(), 0.0));', + plugin = "Rcpp") res <- fx(seq(1, 10, by=0.5)) res ``` @@ -298,9 +288,7 @@ The example above can now be rewritten as: ```{r} cppFunction('double accu(NumericVector x) { - return( - std::accumulate(x.begin(), x.end(), 0.0) - ); + return(std::accumulate(x.begin(), x.end(), 0.0)); }') res <- accu(seq(1, 10, by=0.5)) res @@ -313,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}. @@ -344,11 +332,11 @@ the \proglang{R} expression following the `-e` switch. Such an expression can contain multiple statements separated by semicolons. \rdoc{utils}{Rscript} is available on all three core operating systems. -On Linux, one can also use `r` from the `littler` package by Horner -and Eddelbuettel which is an alternative front end to \proglang{R} designed -for both `#!` (hashbang) scripting and command-line use. It has slightly -faster start-up times than \rdoc{utils}{Rscript}; and both give a guaranteed clean -slate as a new session is created. +On Linux, one can also use `r` from the `littler` package +\citep{CRAN:littler} which is an alternative front end to \proglang{R} +designed for both `#!` (hashbang) scripting and command-line use. It has +slightly faster start-up times than \rdoc{utils}{Rscript}; and both give a +guaranteed clean slate as a new session is created. The example then becomes @@ -360,8 +348,8 @@ $ R CMD INSTALL mypkg && \ The `-l` option calls 'suppressMessages(library(mypkg))' before executing the \proglang{R} expression. Several packages can be listed, separated by a comma. -More choice are provide by the \pkg{devtools} package, and by using -RStudio. See the respective documentation for details. +More choices are provided by other packages and IDEs. See their respective +documentation for details. ## But I want to compile my code with R CMD SHLIB {#using-r-cmd-shlib} @@ -378,8 +366,6 @@ against. On the Linux command-line, you can do the following: ```{bash, eval = FALSE} -$ # if Rcpp older than 0.11.0 -$ export PKG_LIBS=`Rscript -e "Rcpp:::LdFlags()"` $ export PKG_CXXFLAGS=\ `Rscript -e "Rcpp:::CxxFlags()"` $ R CMD SHLIB myfile.cpp @@ -395,13 +381,11 @@ Dirk's older 'Intro to HPC with R' tutorial slides). It is still not recommended as there are tools and automation mechanisms that can do the work for you. -\pkg{Rcpp} versions 0.11.0 or later can do with the definition of -`PKG_LIBS` as a user-facing library is no longer needed (and hence no -longer shipped with the package). One still needs to set `PKG_CXXFLAGS` -to tell R where the \pkg{Rcpp} headers files are located. +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 -extension `.so` on Linux, `.dylib` on OS X or `.dll` on +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 \emph{strongly} recommend using a package, or at least Rcpp Attributes as @@ -432,15 +416,12 @@ of packages using \pkg{Rcpp}. But this only helps in having \proglang{R} compute the location of the header files for us. The actual library location and argument still needs to be provided by the -user. How to do so has been shown above, and we recommned you use either -\faq{make-package} or \faq{using-inline} both which use the \pkg{Rcpp} -function `Rcpp:::LdFlags()`. - -If and when `LinkingTo` changes and lives up to its name, we will be -sure to adapt \pkg{Rcpp} as well. +user. This topic can get complicated real quickly, and there is an entire +vignette devoted to it, so see \citet{CRAN:Rcpp:Libraries}. -An important change arrive with \pkg{Rcpp} release 0.11.0 and concern the -automatic registration of functions; see Section~\ref{function-registration} below. +Also note that an important change arrived with \pkg{Rcpp} release 0.11.0 and +concerns the automatic registration of functions; see +Section \ref{function-registration} below. ## Does \pkg{Rcpp} work on windows @@ -457,6 +438,11 @@ Studio simply do not get along. As \pkg{Rcpp} is all about extending toolchain. And \proglang{R} simply does not compile with Visual Studio. Go complain to its vendor if you are still upset. +(These days the 'Code' editor derived from it is popular and can of course be +used with \proglang{R} and \pkg{Rcpp}; see its documentation for the required +plugins. Such use still falls back to the default compilers \proglang{R} is +used with on the given system so see \faq{q:what-compiler} above.) + ## I am having problems building Rcpp on macOS, any help {#q:OSX} There are three known issues regarding Rcpp build problems on macOS. If you are @@ -476,7 +462,7 @@ manual. ### Differing macOS R Versions Leading to Binary Failures -There are currently _three_ distinct versions of R for macOS. +There are _three_ (or more) distinct versions of R for macOS. The first version is a legacy version meant for macOS 10.6 (Snow Leopard) - 10.8 (Mountain Lion). The second version is for more recent system macOS 10.9 (Mavericks) and 10.10 (Yosemite). Finally, the third and most @@ -491,13 +477,13 @@ able to mix. In such cases, it is better to provide collaborators with the ### OpenMP Support By default, the macOS operating environment lacks the ability to parallelize -sections of code using the \proglang{[OpenMP](http://openmp.org/wp/)} -standard. 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 to -\proglang{OpenMP} as some users may not yet have the ability to -use \proglang{OpenMP}. +sections of code using the [\proglang{OpenMP} +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 +to \proglang{OpenMP} as some users may not yet have the ability to use +\proglang{OpenMP}. To setup the appropriate protection for using \proglang{OpenMP}, the process is two-fold. First, protect the inclusion of headers with: @@ -528,12 +514,12 @@ Below are additional resources that provide information regarding compiling Rcpp 1. A helpful post was provided by Brian Ripley regarding the use of compiling R code with macOS in April 2014 [on the `r-sig-mac` list](https://stat.ethz.ch/pipermail/r-sig-mac/2014-April/010835.html), - which is generally recommended for OS X-specific questions and further consultation. -2. Another helpful write-up for installation / compilation on OS X Mavericks is provided - [by the BioConductor project](http://www.bioconductor.org/developers/how-to/mavericks-howto/). + 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](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. @@ -552,22 +538,25 @@ is. ## Does \pkg{Rcpp} work on solaris/suncc Yes, it generally does. But as we do not have access to such systems, some -issues persist on the CRAN test systems. +issues persist on the CRAN test systems. And now that more time has passed +since the question was written, CRAN no longer tests on these platforms. -## Does \pkg{Rcpp} work with Revolution R +## Does \pkg{Rcpp} work with REvolution R We have not tested it yet. \pkg{Rcpp} might need a few tweaks to work with the compilers used by Revolution R (if those differ from the defaults). +By now REvolution R is defunct too. ## Is it related to Rho (formerly CXXR) 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++} but they do it in very different ways. +By now, Rho is long defunct too. ## How do I quickly prototype my code using Attributes {#prototype-using-attributes} @@ -578,7 +567,7 @@ which is described in detail in its own vignette \rdoc{Rcpp}{cxxfunction} function. -## What about the new 'no-linking' feature {#function-registration} +## What about the 'no-linking' feature {#function-registration} Starting with \pkg{Rcpp} 0.11.0, functionality provided by \pkg{Rcpp} and used by packages built with \pkg{Rcpp} accessed via the registration facility @@ -623,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} @@ -636,19 +625,20 @@ Several dozen fully documented examples are provided at the > script and then initialize an instance of the class and call a method on > the class, all inline in R. -This question was initially about using templates with \pkg{inline}, and we +\noindent This question was initially about using templates with \pkg{inline}, and we show that (older) answer first. It is also easy with Rcpp Attributes which is what we show below. ### Using inline with Templated Code + Most certainly, consider this simple example of a templated class which squares its argument: ```{r} inc <- 'template class square : - public std::unary_function { + public std::function { public: T operator()( T t) const { return t*t; @@ -684,7 +674,7 @@ will even run the R part at the end. #include template class square : - public std::unary_function { + public std::function { public: T operator()( T t) const { return t*t ; @@ -728,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} @@ -743,11 +733,10 @@ arma::colvec z = Rcpp::as(z_) ; // calculate the result double result = arma::as_scalar( - arma::trans(x) * arma::inv(Y) * z - ); + arma::trans(x) * arma::inv(Y) * z); // return it to R -return Rcpp::wrap( result );' +return Rcpp::wrap(result);' writeLines(a, file = "myfile.cpp") ``` @@ -768,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}. @@ -907,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: @@ -936,7 +925,7 @@ call---and will also run the small R example at the end. > How can I create my own plugin for use by the \pkg{inline} package? -Here is an example which shows how to it using GSL libraries as an +\noindent Here is an example which shows how to it using GSL libraries as an example. This is merely for demonstration, it is also not perfectly general as we do not detect locations first---but it serves as an example: @@ -974,18 +963,18 @@ The same plugins can be used by Rcpp Attributes as well. > How can I pass another flag to the `g++` compiler without writing a new plugin? -The quickest way is to modify the return value from an existing plugin. Here -we use the default one from \pkg{Rcpp} itself in order to pass the new flag -`-std=c++0x`. As it does not set the `PKG_CXXFLAGS` variable, we +\noindent The quickest way is to modify the return value from an existing plugin. Here +we use the default one from \pkg{Rcpp} itself in order to pass the flag +`-std=c++11`. As it does not set the `PKG_CXXFLAGS` variable, we simply assign this. For other plugins, one may need to append to the existing -values instead. +values instead. An older example follow (but note that C++11 or newer is the +default now with more recent R releases) ```{r, eval=FALSE} myplugin <- getPlugin("Rcpp") myplugin$env$PKG_CXXFLAGS <- "-std=c++11" f <- cxxfunction(signature(), settings = myplugin, body = ' - // fails without -std=c++0x std::vector x = { 1.0, 2.0, 3.0 }; return Rcpp::wrap(x); ') @@ -993,13 +982,15 @@ f() ``` For Rcpp Attributes, the attributes `Rcpp::plugin()` can be -used. Currently supported plugins are for C++11 as well as for OpenMP. +used. Currently supported plugins are for C++11 (which is now a standard for +compilation with R, but used to be an opt-in), other compilation standards +C++14, C++17, C++20, C++23, as well as for OpenMP. ## How can I set matrix row and column names > Ok, I can create a matrix, but how do I set its row and columns names? -Pretty much the same way as in \proglang{R} itself: We define a list with two +\noindent Pretty much the same way as in \proglang{R} itself: We define a list with two character vectors, one each for row and column names, and assign this to the `dimnames` attribute: @@ -1042,7 +1033,7 @@ Rcpp::List fun(void) { ## Why can long long types not be cast correctly -That is a good and open question. We rely on the basic \proglang{R} types, +\noindent That is a good and open question. We rely on the basic \proglang{R} types, notably `integer` and `numeric`. These can be cast to and from \proglang{C++} types without problems. But there are corner cases. The following example, contributed by a user, shows that we cannot reliably cast @@ -1074,22 +1065,27 @@ 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 +`integer64` as a type (but storing the 64 bits in a `double`), and +\pkg{RcppInt64} \citep{CRAN:RcppInt64} can help with conversion back and +forth. + ## What LaTeX packages do I need to typeset the vignettes > I would like to typeset the vignettes. What do I need? -The [TeXLive](https://www.tug.org/texlive/) distribution seems to get +\noindent The [TeXLive](https://www.tug.org/texlive/) distribution seems to get bigger and bigger. What you need to install may depend on your operating 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. -- **OS X** users seem to fall into camps which like or do not like brew / +- **macOS** users seem to fall into camps which like or do not like brew / homebrew. One suggestion was to install [MacTeX](https://tug.org/mactex/mactex-download.html) but at approximately 2.5gb (as of January 2016) this is not lightweight. @@ -1106,21 +1102,21 @@ Specific per-platform notes: > Ok, I would like to pass $N$ object but you only allow 20. How come? -In essence, and in order to be able to compile it with the largest number of +\noindent In essence, and in order to be able to compile it with the largest number of compilers, \pkg{Rcpp} is constrained by the older C++ standards which do not support variadic function arguments. So we actually use macros and code 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. ## Can I use default function parameters with \pkg{Rcpp} -Yes, you can use default parameters with _some_ limitations. +\noindent Yes, you can use default parameters with _some_ limitations. The limitations are mainly related to string literals and empty vectors. This is what is currently supported: @@ -1172,26 +1168,27 @@ 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 the language standard which is useful for `sourceCpp()` etc. For packages, R has supported it since R 3.1.0 which added the option to select the language standard via `CXX_STD = CXX11`. As of early 2017, over 120 - packages on CRAN use this. + packages on CRAN use this. As of R 4.0.0, this is the minimum standard and + no longer needed. - _C++14_: has been supported since early 2016 via a plugin selecting the language standard which is useful for `sourceCpp()` etc. For packages, R supports it since R 3.4.0 adding the option to select the language - standard via `CXX_STD = CXX14`. -- _C++17_: is itself more experimental now, but if you have a compiler - supporting (at least parts of) it, you can use it via plugin (starting with - Rcpp 0.12.10) for use via `sourceCpp()`, or via `PKG_CXXFLAGS` or - other means to set compiler options. R support may be available at a later - date. + standard via `CXX_STD = CXX14`. It became the default with R 4.1.0. +- _C++17_: it has been supported (with an appropriate compiler) via plugin starting with + Rcpp 0.12.10, or use via `sourceCpp()`, or via `PKG_CXXFLAGS` or + other means to set compiler options. It became the default with R 4.3.0, + but compiler support may not be widespread. +- _C++20_: It is also supported (given a suitable compiler) since Rcpp 1.0.11. ## How do I use it within (Python's) Conda setup? @@ -1204,7 +1201,28 @@ 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? + +Somewhat. One option is to cache as much as possible via +[ccache](https://ccache.dev/) by adding it to `~/.R/Makevars`. + +Depending on what parts of Rcpp are being used, compilation speed can be +increased by turning use of Modules off. Starting with version 1.0.3, the +`RCPP_NO_MODULES` define can be used. It can be set in `src/Makevars` as +an argument to `PKG_CXXFLAGS` (or one of the other C++ dialect options) as +`-DRCPP_NO_MODULES`. This has the advantage of affecting _all_ files in the +package, including the auto-generated `RcppExports.cpp` where it might be +trickier to set it manually. + +Beyond modules, RTTI support can also be turned off. this implies turning +Modules support off as well so. To select this approach, use the +`RCPP_NO_RTTI` define. + +Starting with version 1.0.8 of \pkg{Rcpp}, new headers \code{Rcpp/Light}, +\code{Rcpp/Lighter}, \code{Rcpp/Lightest} make this much easier as they +exclude these different (layered) bits of functionality. # Support @@ -1212,16 +1230,16 @@ systems is provided 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 @@ -1234,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) @@ -1260,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} @@ -1284,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 @@ -1434,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. @@ -1555,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 @@ -1567,9 +1584,9 @@ under the specification for \proglang{C++11} or later version. 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 is engaged by adding +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} @@ -1714,9 +1731,90 @@ 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 by the linker, consider running `compileAttributes()` twice. Deleting `R/RcppExports.R` and `src/RcppExports.cpp` may also work. + +## Can we use exceptions and stop() across shared libraries? + +Within limits, yes. Code that is generated via Rcpp Attributes (see +\citet{CRAN:Rcpp:Attributes} and Section~\ref{using-attributes}) generally +handles this correctly and gracefully via the `try-catch` layer it adds +shielding the exception from propagating to another, separate dynamic +library. + +However, this mechanism relies on dynamic linking with the (system library) +`libgcc` providing the C++ standard library (as well as on using the same C++ +standard library across all compiled components). But this library is linked +statically on Windows putting a limitation on the use of `stop()` from within +Rcpp Modules \citep{CRAN:Rcpp:Modules}. Some more background on the linking +requirement is [in this SO +question](https://stackoverflow.com/questions/2424836/exceptions-are-not-caught-in-gcc-program). + +## My package errors with "'dataptr' not provided by Rcpp" + +If you see tests of your package fail with an error '... not provided by +Rcpp', frequently pointing at either `dataptr` or `enterRNGScope`, then the +\pkg{Rcpp} package may not have been initialized correctly. For your +package, it is generally recommended to have both `Imports: Rcpp` and +`LinkingTo: Rcpp` in the file `DESCRIPTION` combined with an explicit +`importFrom("Rcpp", "evalCpp")` in the file `NAMESPACE`. Doing so ensures +that this symbol is registered when your package is loaded by R, and as a +side-effect certain other \pkg{Rcpp} function identifiers will also be +resolved properly. + +## On macOS, 'no matching function for call to `R_lsInternal`' + +In issue [#1148](https://github.com/RcppCore/Rcpp/issues/1148) an error due +to overeager includes was reported. Including `Rinternals.h` along with the +(macOS-only) `mach/boolean.h` lead to linker error as `mach/boolean` +redefines `TRUE` leading to bad interactions with the `Rboolean` enum type. A +very simple solution is to be more careful and conservative with `#include` +files and a) have `#include ` appear first and b) skip +the `#include ` as it is included by `Rcpp.h` anyway. + +## Can we grow Rcpp vectors like STL vectors via 'push*' + +No. Use actual STL vectors instead. This has been stated clearly many times going +back to the [original announcement in Feb 2010](https://lists.r-forge.r-project.org/pipermail/rcpp-devel/2010-February/000410.html), +StackOverflow answers in [Dec 2011](https://stackoverflow.com/a/8631853/143305) +and in [Dec 2012](https://stackoverflow.com/a/13783044/143305), +the rcpp-devel list in [Jun 2013](https://lists.r-forge.r-project.org/pipermail/rcpp-devel/2013-June/006078.html), +another StackOverflow answer in [Nov 2013](https://stackoverflow.com/a/19829440/143305), +an early Rcpp Gallery post in [Dec 2013](https://gallery.rcpp.org/articles/plyr-c-to-rcpp/), +again on StackOverflow [Dec 2014](https://stackoverflow.com/a/27585789/143305), as well as in +the 'Advanced R' [first](http://adv-r.had.co.nz/Rcpp.html#stl) and +[second](https://adv-r.hadley.nz/rcpp.html#stl) editions. +For emphasis, here is a quote from the [rcpp-devel post](https://lists.r-forge.r-project.org/pipermail/rcpp-devel/2013-June/006078.html): + +> Those are somehow cosmetic additions. The usual suggestion is not to +> use push_front and push_back on Rcpp types. +> +> We use R's memory, and in R, resizing a vector means moving the data. +> So if you push_back 3 times, you're moving the data 3 times. +> +> Using R own memory is the best ever decision we made in Rcpp. You can +> always use your own data structures to accumulate data, perhaps using +> stl types and then convert back to R types, which is something we make +> easy to do. + +Many code examples and packages show exactly that approach (as _e.g._ discussed +in the [Rcpp Gallery post](https://gallery.rcpp.org/articles/plyr-c-to-rcpp/)). +Anybody who claims otherwise is (possibly intentionally) misleading. + +## Converting a large number of Date objects seems slow + +The `Date` and `Datetime` classes, and their vector variants, go back a very +long time to the very beginning of \pkg{Rcpp} and use in \pkg{RQuantLib} +\citep{CRAN:RQuantLib} interfacing \pkg{QuantLib} \citep{QuantLib}. Their intent was, +essentially, to hold (single) start and end values delineating an interval. The +design is far from optimal, but the interface is now established. We have +rewritten them once, and do not plan to rewrite them in the near future. Those +looking to _parse and convert_ many dates at once could look at \pkg{anytime} +\citep{CRAN:anytime} where we use the Boost parser, or similar approaches using +the C++ headers-only libraries in packages \pkg{RcppCCTZ} \citep{CRAN:RcppCCTZ} +and \pkg{RcppDate} \citep{CRAN:RcppDate}. We are not likely to carry this over to +the \pkg{Rcpp} package as there are advantages in remaining dependency-free. diff --git a/vignettes/Rcpp-attributes.Rmd b/vignettes/rmd/Rcpp-attributes.Rmd similarity index 93% rename from vignettes/Rcpp-attributes.Rmd rename to vignettes/rmd/Rcpp-attributes.Rmd index b434f5056..0115031d9 100644 --- a/vignettes/Rcpp-attributes.Rmd +++ b/vignettes/rmd/Rcpp-attributes.Rmd @@ -12,12 +12,12 @@ 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 @@ -61,7 +61,7 @@ numbersections: true # Optional: Specify the depth of section number, default is 5 #secnumdepth: 5 -# Optional: Bibliography +# Optional: Bibliography bibliography: Rcpp # Optional: Enable a 'Draft' watermark on the document @@ -117,7 +117,7 @@ Attributes can also be used for package development via the `extern "C"` and `.Call` wrappers for \proglang{C++} functions within packages. -# Using Attributes +# Using Attributes Attributes are annotations that are added to C++ source files to provide additional information to the compiler. \pkg{Rcpp} supports attributes @@ -129,7 +129,7 @@ as well as to optionally specify additional build dependencies for source files. fully supported across all compilers, \pkg{Rcpp} attributes are included in source files using specially formatted comments. -## Exporting C++ Functions +## Exporting C++ Functions The `sourceCpp` function parses a \proglang{C++} file and looks for functions marked with the `Rcpp::export` attribute. A shared @@ -171,11 +171,11 @@ and \pkg{Rcpp} wrapper types and then source them just as we would an \proglang{R} script. The `sourceCpp` function performs caching based on the last -modified date of the source file and it's local dependencies so as -long as the source does not change the compilation will occur only +modified date of the source file and it's local dependencies so as +long as the source does not change the compilation will occur only once per R session. -## Specifying Argument Defaults +## Specifying Argument Defaults If default argument values are provided in the C++ function definition then these defaults are also used for the exported R function. For example, @@ -187,7 +187,7 @@ DataFrame readData(CharacterVector file, CharacterVector::create(), std::string comment = "#", bool header = true) -``` +``` Will be exported to R as: @@ -214,7 +214,7 @@ Not all \proglang{C++} default argument values can be parsed into their - `Matrix` types instantiated using the `rows`, `cols` constructor. -## Signaling Errors +## Signaling Errors Within \proglang{R} code the `stop` function is typically used to signal errors. Within \proglang{R} extensions written in \proglang{C} the `Rf_error` function is typically used. However, within \proglang{C++} code you cannot @@ -249,12 +249,12 @@ if (unexpectedCondition) Rcpp::warning("Unexpected condition occurred"); ``` -## Supporting User Interruption +## Supporting User Interruption If your function may run for an extended period of time, users will appreciate the ability to interrupt it's processing and return to the REPL. This is handled automatically for R code (as R checks for user interrupts periodically -during processing) however requires explicit accounting for in C and C++ +during processing) however requires explicit accounting for in C and C++ extensions to R. To make computations interrupt-able, you should periodically call the `Rcpp::checkUserInterrupt` function, for example: @@ -263,7 +263,7 @@ for (int i=0; i<1000000; i++) { // check for interrupt every 1000 iterations if (i % 1000 == 0) Rcpp::checkUserInterrupt(); - + // ...do some expensive work... } ``` @@ -273,13 +273,13 @@ seconds that your computation is running. In the above code, if the user requests an interrupt then an exception is thrown and the attributes wrapper code arranges for the user to be returned to the REPL. -Note that R provides a \proglang{C} API for the same purpose -(`R_CheckUserInterrupt`) however this API is not safe to use in +Note that R provides a \proglang{C} API for the same purpose +(`R_CheckUserInterrupt`) however this API is not safe to use in \proglang{C++} code as it uses `longjmp` to exit the current scope, bypassing any C++ destructors on the stack. The `Rcpp::checkUserInterrupt` function is provided as a safe alternative for \proglang{C++} code. -## Embedding R Code +## Embedding R Code Typically \proglang{C++} and \proglang{R} code are kept in their own source files. However, it's often convenient to bundle code from both languages into @@ -302,7 +302,7 @@ Multiple \proglang{R} code chunks can be included in a \proglang{C++} file. The `sourceCpp` function will first compile the \proglang{C++} code into a shared library and then source the embedded \proglang{R} code. -## Modifying Function Names +## Modifying Function Names You can change the name of an exported function as it appears to \proglang{R} by adding a name parameter to `Rcpp::export`. For example: @@ -318,7 +318,23 @@ exported R function will be hidden. You can also use this method to provide implementations of S3 methods (which wouldn't otherwise be possible because C++ functions can't contain a '.' in their name). -## Function Requirements +## Returning invisible object + +Typically, only `void`-returning functions are wrapped by `invisible()` in +`RcppExports.R`. In some cases, however, it is preferred to return an object +invisibly. This can be done by adding an invisible parameter to `Rcpp::export`. +For example: + +```{Rcpp, eval = FALSE} +// [[Rcpp::export(invisible = true)]] +NumericVector convolveCpp(NumericVector a, + NumericVector b) +``` + +Then the R wrapper of `convolveCpp` will return `invisible(.Call(...))` rather +than `.Call(...)`. + +## Function Requirements Functions marked with the `Rcpp::export` attribute must meet several requirements to be correctly handled: @@ -332,7 +348,7 @@ requirements to be correctly handled: `DataFrame` is okay as a type name but `std::string` must be specified fully). -## Random Number Generation +## Random Number Generation \proglang{R} functions implemented in \proglang{C} or \proglang{C++} need to be careful to surround use of internal random number generation routines @@ -346,10 +362,10 @@ Note that \pkg{Rcpp} implements `RNGScope` using a counter, so it's still safe to execute code that may establish it's own `RNGScope` (such as the \pkg{Rcpp} sugar functions that deal with random number generation). -The overhead associated with using `RNGScope` is negligible (only a +The overhead associated with using `RNGScope` is negligible (only a couple of milliseconds) and it provides a guarantee that all C++ code -will inter-operate correctly with R's random number generation. If you are -certain that no C++ code will make use of random number generation and the +will inter-operate correctly with R's random number generation. If you are +certain that no C++ code will make use of random number generation and the 2ms of execution time is meaningful in your context, you can disable the automatic injection of `RNGScope` using the `rng` parameter of the `Rcpp::export` attribute. For example: @@ -358,11 +374,11 @@ of the `Rcpp::export` attribute. For example: // [[Rcpp::export(rng = false)]] double myFunction(double input) { // ...code that never uses the - // R random number generation... + // R random number generation... } ``` -## Importing Dependencies +## Importing Dependencies It's also possible to use the `Rcpp::depends` attribute to declare dependencies on other packages. For example: @@ -384,7 +400,7 @@ List fastLm(NumericVector yr, NumericMatrix Xr) { arma::colvec coef = arma::solve(X, y); arma::colvec rd = y - X*coef; - double sig2 = + double sig2 = arma::as_scalar(arma::trans(rd)*rd/(n-k)); arma::colvec sderr = arma::sqrt(sig2 * arma::diagvec(arma::inv(arma::trans(X)*X))); @@ -392,7 +408,7 @@ List fastLm(NumericVector yr, NumericMatrix Xr) { return List::create(Named("coef") = coef, Named("sderr")= sderr); } -``` +``` The inclusion of the `Rcpp::depends` attribute causes `sourceCpp` to configure the build environment to correctly compile and link against the @@ -412,24 +428,24 @@ source file in an \proglang{R} package these dependencies must still be listed in the `Imports` and/or `LinkingTo` fields of the package `DESCRIPTION` file. -## Sharing Code +## Sharing Code The core use case for `sourceCpp` is the compilation of a single self-contained source file. Code within this file can import other C++ code by using the `Rcpp::depends` attribute as described above. -The recommended practice for sharing C++ code across many uses of +The recommended practice for sharing C++ code across many uses of `sourceCpp` is therefore to create an R package to wrap the C++ code. This has many benefits not the least of which is easy distribution of shared code. More information on creating packages that contain C++ code is included in the Package Development section below. -### Shared Code in Header Files +### Shared Code in Header Files -If you need to share a small amount of C++ code between source files +If you need to share a small amount of C++ code between source files compiled with `sourceCpp` and the option of creating a package isn't practical, then you can also share code using local includes of C++ -header files. To do this, create a header file with the definition of +header files. To do this, create a header file with the definition of shared functions, classes, enums, etc. For example: ```{Rcpp, eval = FALSE} @@ -444,9 +460,9 @@ inline double timesTwo(double x) { ``` Note the use of the `#ifndef` include guard, this is important to ensure -that code is not included more than once in a source file. You should +that code is not included more than once in a source file. You should use an include guard and be sure to pick a unique name for the corresponding -`#define`. +`#define`. Also note the use of the \code{inline} keyword preceding the function. This is important to ensure that there are not multiple definitions of @@ -454,7 +470,7 @@ functions included from header files. Classes fully defined in header files automatically have inline semantics so don't require this treatment. To use this code in a source file you'd just include -it based on it's relative path (being sure to use `"` as the +it based on it's relative path (being sure to use `"` as the delimiter to indicate a local file reference). For example: ```{Rcpp, eval = FALSE} @@ -466,14 +482,14 @@ double transformValue(double x) { } ``` -### Shared Code in C++ Files +### Shared Code in C++ Files When scanning for locally included header files \code{sourceCpp} also checks for a corresponding implementation file and automatically includes it in the compilation if it exists. This enables you to break the shared code entirely into it's own source file. -In terms of the above example, this would mean having only a function +In terms of the above example, this would mean having only a function declaration in the header: ```{Rcpp, eval = FALSE} @@ -485,7 +501,7 @@ double timesTwo(double x); #endif // __UTILITIES__ ``` -Then actually defining the function in a separate source file with the +Then actually defining the function in a separate source file with the same base name as the header file but with a .cpp extension (in the above example this would be \code{utilities.cpp}): @@ -497,20 +513,20 @@ double timesTwo(double x) { } ``` -It's also possible to use attributes to declare dependencies and exported +It's also possible to use attributes to declare dependencies and exported functions within shared header and source files. This enables you to take a source file that is typically used standalone and include it when compiling -another source file. +another source file. Note that since additional source files are processed as separate translation units the total compilation time will increase proportional to the number of -files processed. From this standpoint it's often preferable to use shared +files processed. From this standpoint it's often preferable to use shared header files with definitions fully inlined as demonstrated above. Note also that embedded R code is only executed for the main source file not those referenced by local includes. -## Including C++ Inline +## Including C++ Inline Maintaining C++ code in it's own source file provides several benefits including the ability to use \proglang{C++} aware text-editing tools and straightforward @@ -540,7 +556,7 @@ You can also specify a depends parameter to `cppFunction` or `evalCpp`: cppFunction(depends='RcppArmadillo', code='...') ``` -# Package Development +# Package Development One of the goals of \pkg{Rcpp} attributes is to simultaneously facilitate ad-hoc and interactive work with \proglang{C++} while also making it very easy to @@ -554,7 +570,7 @@ moving code from a standalone \proglang{C++} source file to a package: 1. Packages provide additional infrastructure for testing, documentation and consistency -## Package Creation +## Package Creation To create a package that is based on \pkg{Rcpp} you should follow the guidelines in the '\textsl{Rcpp-package}' vignette. For a new package this @@ -575,9 +591,9 @@ with `sourceCpp` you can use the `cpp_files` parameter: Rcpp.package.skeleton("NewPackage", example_code = FALSE, cpp_files = c("convolve.cpp")) -``` +``` -## Specifying Dependencies +## Specifying Dependencies Once you've migrated \proglang{C++} code into a package, the dependencies for source files are derived from the `Imports` and `LinkingTo` fields @@ -597,7 +613,7 @@ entries in the `DESCRIPTION` file: ```{bash, eval = FALSE} Imports: Rcpp (>= 0.11.4) LinkingTo: Rcpp -``` +``` And the following entry in your `NAMESPACE` file: @@ -612,10 +628,10 @@ you'd just add an entry for \pkg{BH} to the `LinkingTo` field since ```{bash, eval = FALSE} Imports: Rcpp (>= 0.11.4) LinkingTo: Rcpp, BH -``` +``` -## Exporting R Functions +## Exporting R Functions Within interactive sessions you call the `sourceCpp` function on individual files to export \proglang{C++} functions into the global @@ -639,7 +655,7 @@ Results in the generation of the following two source files: You should re-run `compileAttributes` whenever functions are added, removed, or have their signatures changed. Note that if you are using either -RStudio or \pkg{devtools} to build your package then the +RStudio or \pkg{devtools} to build your package then the `compileAttributes` function is called automatically whenever your package is built. @@ -656,7 +672,7 @@ Rcpp attribute compilation will automatically generate a package R_init function You may however want to add additional C++ code to the package initialization sequence. To do this, you can add the `[[Rcpp::init]]` attribute to functions within your package. For example: -```{cpp, eval = FALSE} +```{Rcpp, eval = FALSE} // [[Rcpp::init]] void my_package_init(DllInfo *dll) { // initialization code here @@ -665,22 +681,23 @@ void my_package_init(DllInfo *dll) { In this case, a call to `my_package_init()` will be added to the end of the automatically generated R_init function within RcppExports.cpp. For example: -```{cpp, eval = FALSE} +```{Rcpp, eval = FALSE} void my_package_init(DllInfo *dll); RcppExport void R_init_pkgname(DllInfo *dll) { - R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); + R_registerRoutines(dll, NULL, CallEntries, + NULL, NULL); R_useDynamicSymbols(dll, FALSE); my_package_init(dll); } ``` -## Types in Generated Code +## Types in Generated Code In some cases the signatures of the C++ functions that are generated within -`RcppExports.cpp` may have additional type requirements beyond the core +`RcppExports.cpp` may have additional type requirements beyond the core standard library and \pkg{Rcpp} types (e.g. `CharacterVector`, `NumericVector`, etc.). Examples might include convenience typedefs, -as/wrap handlers for marshaling between custom types and SEXP, or types +as/wrap handlers for marshaling between custom types and SEXP, or types wrapped by the Rcpp `XPtr` template. In this case, you can create a header file that contains these type definitions @@ -700,20 +717,20 @@ inst/include/fastcode_types.hpp There is one other mechanism for type visibility in `RcppExports.cpp`. If your package provides a master include file for consumption by C++ clients -then this file will also be automatically included. For example, if the +then this file will also be automatically included. For example, if the \pkg{fastcode} package had a C++ API and the following header file: ```{Rcpp, eval = FALSE} inst/include/fastcode.h ``` -This header file will also automatically be included in +This header file will also automatically be included in `RcppExports.cpp`. Note that the convention of using `.h` for header files containing C++ code may seem unnatural, but this comes from the -recommended practices described in '\textsl{Writing R Extensions}' +recommended practices described in '\textsl{Writing R Extensions}' \citep{R:Extensions}. -## Roxygen Comments +## Roxygen Comments The \pkg{roxygen2} package \citep{CRAN:roxygen2} provides a facility for automatically generating \proglang{R} documentation files based on specially @@ -743,7 +760,7 @@ Results in the following code in the generated \proglang{R} source file: strLength <- function(str) ``` -## Providing a C++ Interface +## Providing a C++ Interface The interface exposed from \proglang{R} packages is most typically a set of \proglang{R} functions. However, the \proglang{R} package system also provides @@ -759,7 +776,7 @@ system automatically adds the required `include` directories for all packages specified in the `LinkingTo` field of the package `DESCRIPTION` file. -### Interfaces Attribute +### Interfaces Attribute The `Rcpp::interfaces` attribute can be used to automatically generate a header-only interface to your \proglang{C++} functions @@ -779,7 +796,7 @@ should be generated for a source file: Note that the default behavior if an `Rcpp::interfaces` attribute is not included in a source file is to generate an R interface only. -### Generated Code +### Generated Code If you request a `cpp` interface for a source file then `compileAttributes` generates the following header files @@ -815,7 +832,7 @@ void foo() { } ``` -### Including Additional Code +### Including Additional Code You might wish to use the `Rcpp::interfaces` attribute to generate a part of your package's \proglang{C++} interface but also provide diff --git a/vignettes/Rcpp-extending.Rmd b/vignettes/rmd/Rcpp-extending.Rmd similarity index 93% rename from vignettes/Rcpp-extending.Rmd rename to vignettes/rmd/Rcpp-extending.Rmd index c83bc30f4..1ff14ed98 100644 --- a/vignettes/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 @@ -134,8 +134,8 @@ input <- list( x = seq(1, 10, by = 0.5) ) fx(input) ``` -The \pkg{Rcpp} converter function `Rcpp::as` and `Rcpp::wrap` have been -designed to be extensible to user-defined types and third-party types. +The \pkg{Rcpp} converter functions `Rcpp::as` and `Rcpp::wrap` are +extensible to user-defined types and third-party types. # Extending `Rcpp::wrap` @@ -204,11 +204,13 @@ full advantage of the \pkg{Rcpp} type system. Another non-intrusive option is to expose an external pointer. The macro `RCPP_EXPOSED_WRAP` provides an easy way to expose a \proglang{C++} class to \proglang{R} as an external pointer. It can be used instead of specializing -`Rcpp::wrap`, and should not be used simultaneously. +`Rcpp::wrap`, and should not be used simultaneously. Note that the +\proglang{C++} class has to use Rcpp modules. See the Rcpp modules vignette for +more details. ```{Rcpp, eval = FALSE} -#include RcppCommon.h -#include foobar.h +#include +#include RCPP_EXPOSED_WRAP(Bar) ``` @@ -264,7 +266,6 @@ class Foo{ Foo(SEXP); } - // this must appear after the specialization, or // specialization will not be seen by Rcpp types #include @@ -295,11 +296,12 @@ Furthermore, another non-intrusive option is to opt for sharing an R external pointer. The macro `RCPP_EXPOSED_AS` provides an easy way to extend `Rcpp::as` to expose \proglang{R} external pointers to \proglang{C++}. It can be used instead of specializing `Rcpp::as`, and -should not be used simultaneously. +should not be used simultaneously. Note that the \proglang{C++} class +has to use Rcpp modules. See the Rcpp modules vignette for more details. ```{Rcpp, eval = FALSE} -#include RcppCommon.h -#include foobar.h +#include +#include RCPP_EXPOSED_AS(Bar) ``` diff --git a/vignettes/Rcpp-introduction.Rmd b/vignettes/rmd/Rcpp-introduction.Rmd similarity index 96% rename from vignettes/Rcpp-introduction.Rmd rename to vignettes/rmd/Rcpp-introduction.Rmd index 46128378b..638a44678 100644 --- a/vignettes/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 }} @@ -86,7 +86,7 @@ vignette: > --- ```{r setup, include=FALSE} -knitr::opts_chunk$set(cache=TRUE) +knitr::opts_chunk$set(cache=FALSE) library(Rcpp) options("width"=50, digits=5) ``` @@ -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: @@ -561,7 +560,7 @@ result_r <- bootstrap_r(initdata) Figure \ref{fig:bootstrap-graphs} shows that the bootstrap procedure worked well! -```{r dist_graphs, echo = FALSE, results = "hide"} +```{r dist_graphs, echo = FALSE, results = "hide", eval=FALSE} make_boot_graph <- function(ds, actual, type, ylim){ hist(ds, main = paste(type, "Bootstrap"), xlab = "Samples", col = "lightblue", lwd = 2, prob = TRUE, ylim = ylim, cex.axis = .85, cex.lab = .90) @@ -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 @@ -873,7 +872,7 @@ Rcpp.package.skeleton("samplePkg") \begin{figure} \begin{center} \includegraphics[width=3in]{figures/samplePkg-files-light-bg.png} - \caption{Graphical annotation of the \texttt{is\_odd\_cpp} function.} + \caption{Illustration of \texttt{Rcpp.package.skeleton} function.} \label{fig:package-files} \end{center} \end{figure} diff --git a/vignettes/Rcpp-jss-2011.Rnw b/vignettes/rmd/Rcpp-jss-2011.Rnw similarity index 99% rename from vignettes/Rcpp-jss-2011.Rnw rename to vignettes/rmd/Rcpp-jss-2011.Rnw index 591e62f3f..954c2ceed 100644 --- a/vignettes/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 new file mode 100644 index 000000000..03c56d050 --- /dev/null +++ b/vignettes/rmd/Rcpp-libraries.Rmd @@ -0,0 +1,403 @@ +--- +title: Thirteen Simple Steps for Creating An R Package with an External C++ Library + +# Use letters for affiliations +author: + - name: Dirk Eddelbuettel + affiliation: 1 + +address: + - code: 1 + address: Department of Statistics, University of Illinois, Urbana-Champaign, IL, USA + +# For footer text TODO(fold into template, allow free form two-authors) +lead_author_surname: Eddelbuettel + +# Place DOI URL or CRAN Package URL here +doi_footer: "https://arxiv.org/abs/1911.06416" + +# Abstract +abstract: | + 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 + \citep{github:rcppcorels}. We discuss each step in the process, and derive a set of + simple rules and recommendations which are illustrated with the concrete example. + + +# Font size of the document, values of 9pt (default), 10pt, 11pt and 12pt +fontsize: 9pt + +# Optional: Force one-column layout, default is two-column +two_column: 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 +#one_sided: true + +# Optional: Enable section numbering, default is unnumbered +#numbersections: true + +# Optional: Specify the depth of section number, default is 5 +#secnumdepth: 5 + +# Optional: Skip inserting final break between acknowledgements, default is false +skip_final_break: true + +# Optional: Bibliography +# bibliography: references + +# Optional: Enable a 'Draft' watermark on the document +watermark: false + +# Customize footer, eg by referencing the vignette +footer_contents: "Thirteen Steps for R and C++ Library Packages" + +# Produce a pinp document +output: + pinp::pinp: + collapse: true + keep_tex: false + +header-includes: > + \newcommand{\proglang}[1]{\textsf{#1}} + \newcommand{\pkg}[1]{\textbf{#1}} + +vignette: > + %\VignetteIndexEntry{Rcpp-Libraries} + %\VignetteKeywords{Rcpp, Package, Library} + %\VignettePackage{Rcpp} + %\VignetteEngine{knitr::rmarkdown} + %\VignetteEncoding{UTF-8} +--- + +```{r initialsetup, include=FALSE} +knitr::opts_chunk$set(cache=TRUE) +cwd <- getwd() +``` + +# Introduction + +The process of building a new package with Rcpp can range from the very easy---a single +simple C++ function---to the very complex. If, and how, external resources are utilised +makes a big difference as this too can range from the very simple---making use of a +header-only library, or directly including a few C++ source files without further +dependencies---to the very complex. + +Yet a lot of the important action happens in the middle ground. Packages may bring their +own source code, but also depend on just one or two external libraries. This paper +describes one such approach in detail: how we turned the Corels application +\citep{arxiv:corels,github:corels} (provided as a standalone C++-based executable) into an +R-callable package \pkg{RcppCorels} \citep{github:rcppcorels} via \pkg{Rcpp} +\citep{CRAN:Rcpp,JSS:Rcpp}. + +# The Thirteen Key Steps + +## Ensure Use of a Suitable license + +Before embarking on such a journey, it is best to ensure that the licensing framework is +suitable. Many different open-source licenses exists, yet a few key ones dominate and can +generally be used _with each other_. There is however a fair amount of possible legalese +involved, so it is useful to check inter-license compatibility, as well as general +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://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. + +## Ensure the Software builds + +In order to see how hard it may to combine an external entity, either a program a library, +with R, it helps to ensure that the external entity actually still builds and runs. + +This may seem like a small and obvious steps, but experience suggests that it worth +asserting the ability to build with current tools, and possibly also with more than one +compiler or build-system. Consideration to other platforms used by R also matter a great +deal as one of the strengths of the R package system is its ability to cover the three key +operating system families. + +## Ensure it still works + +This may seem like a variation on the previous point, but besides the ability to _build_ +we also need to ensure the ability to _run_ the software. If the external entity has +tests and demo, it is highly recommended to run them. If there are reference results, we +should ensure that they are still obtained, and also that the run-time performance it +still (at a minimum) reasonable. + +## Ensure it is compelling + +This is of course a very basic litmus test: is the new software relevant? Is is helpful? +Would others benefit from having it packaged and maintained? + +## Start an Rcpp package + +The first step in getting a new package combing R and C++ is often the creation of a new +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 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`. + +Any code added by the helper functions, often just a simple `helloWorld()` variant, can be +run to ensure that the package is indeed functional. More importantly, at this stage, we +can also start building the package as a compressed tar archive and run the R checker on +it. + +## Integrate External Package + +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 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. + +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; +- create a minimal `src/Makevars` file, initially with link instructions for GMP later relaxed to + conditional use of GMP (see below); +- moved `main.cc` to a subdirectory as we cannot build with another `main()` function (and R will not include files from subdirectories); +- added a minimal R-callable function along with a `logger` instance. + +Here, the last step was needed as the file `main.cc` provided a global instance referred +to from other files. Hence, a minimal R-callable wrapper is being added at this stage +(shown in the appendix as well). Actual functionality will be added later. + +We will come back to the step concerning the link instructions. + +As this point we have a package for R also containing the library we want to add. + +## Make the External Code compliant with R Policies + +R has fairly strict guidelines, defined both in the _CRAN Repository Policy_ document at +the CRAN website, and in the manual _Writing R Extension_. Certain standard C and C++ +functions are not permitted as their use could interfere with running code from R. This +includes somewhat obvious recommendations ("do not call `abort`" as it would terminate the +R sessions) but extends to not using native print methods in order to cooperate better +with the input and output facilities of R. So here, and reflecting that last aspect, we +changed all calls to `printf()` to calls to `Rprintf()`. Similarly, R prefers its own +(well-tested) random-number generators so we replaced one (scaled) call to `random() / +RAND_MAX` with the equivalent call to R's `unif_rand()`. We also avoided one use of +`stdout` in `rulelib.h`. + +The requirement for such changes may seem excessive at first, but the value added stemming +from consistent application of the CRAN Policies is appreciated by most R users. + +## Complete the Interface + +In order to further test the package, and of course also for actual use, we need to expose +the key parameters and arguments. Corels parsed command-line arguments; we can translate +this directly into suitable arguments for the main function. At a first pass, we created the +following interface: + +```c++ +// [[Rcpp::export]] +bool corels(std::string rules_file, + std::string labels_file, + std::string log_dir, + std::string meta_file = "", + bool run_bfs = false, + bool calculate_size = false, + bool run_curiosity = false, + int curiosity_policy = 0, + bool latex_out = false, + int map_type = 0, + int verbosity = 0, + int max_num_nodes = 100000, + double regularization = 0.01, + int logging_frequency = 1000, + int ablation = 0) { + + // actual function body omitted +} +``` + +Rcpp facilities the integration by adding another wrapper exposing all the function +arguments, and setting up required arguments without default (the first three) along with +optional arguments given a default. The user can now call `corels()` from R with three +required arguments (the two input files plus the log directory) as well as number of +optional arguments. + +## Add Sample Data + +R package can access data files that are shipped with them. That is very useful feature, +and we therefore also copy in the files include in the Corels repository and its `data/` +directory. + +```{r} +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 help page for function `corels()` and can be run from R via +`example("corels")`. + +```r +library(RcppCorels) + +.sysfile <- function(f) # helper function + system.file("sample_data",f,package="RcppCorels") + +rules_file <- .sysfile("compas_train.out") +label_file <- .sysfile("compas_train.label") +meta_file <- .sysfile("compas_train.minor") +logdir <- tempdir() + +stopifnot(file.exists(rules_file), + file.exists(labels_file), + file.exists(meta_file), + dir.exists(logdir)) + +corels(rules_file, labels_file, logdir, meta_file, + verbosity = 100, + regularization = 0.015, + curiosity_policy = 2, # by lower bound + map_type = 1) # permutation map + +cat("See ", logdir, " for result file.") +``` + +In the example, we pass the two required arguments for rules and labels files, the +optional argument for the 'meta' file as well as an added required argument for the output +directory. R policy prohibits writing in user-directories, we default to using the +temporary directory of the current session, and report its value at the end. For other +arguments default values are used. + +## Finesse Library Dependencies + +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. + +The simplest approach is to declare a compile-time variable in the `src/Makevars` file. Using +`-DGMP` _defines_ the `GMP` variable at the level of the C and C++ code. One can then condition on +the variable. A very standard approach, also used here is `#if defined(GMP) ... #else ... #endif` +where one of the two code branches is in effect depending on whether the `GMP` variable is defined +or not. + +In order to detect presence of a required (or optional) library, tools like 'autoconf' or 'cmake' +are often used. For example, one can rely of an existing 'autoconf' macro provided by the GMP +documentation to detect presence of the the GNU GMP header and library. We are making use of this +facility here to deploy GMP when it is available. As 'Corels' can be built with and without GMP, +the build and installation succeeds either way---but deployment of the more-featureful variant with +use GMP is automated. + +## Finalise License and Copyright + +It is good (and common) practice to clearly attribute authorship. Here, credit is given to +the 'Corels' team and authors as well as to the authors of the underlying 'rulelib' code +used by 'Corels' via the file `inst/AUTHORS` (which will be installed as `AUTHORS` with +the package. In addition, the file `inst/LICENSE` clarifies the GNU GPL-3 license for 'RcppCorels' and 'Corels', and the MIT license for 'rulelib'. + +## Additional Bonus: Some more 'meta' files + +Several files help to improve the package. For example, `.Rbuildignore` allows to exclude +listed files from the resulting R package keeping it well-defined. Similarly, `.gitignore` +can exclude files from being added to the `git` repository. We also like `.editorconfig` +for consistent editing default across a range of modern editors. + +# Summary + +We describe s series of steps to turn the standalone library 'Corels' describes by +\citet{arxiv:corels} into a R package \pkg{RcppCorels} using the facilities offered by +\pkg{Rcpp} \citep{CRAN:Rcpp}. Along the way, we illustrate key aspects of the R package +standards and CRAN Repository Policy proving a template for other research software +wishing to provide their implementations in a form that is accessibly by R users. + + +\bibliography{Rcpp} +\bibliographystyle{jss} + +\newpage +\onecolumn + +## Appendix 1: Creating the basic package + +```sh +edd@rob:~/git$ r --packages Rcpp --eval 'Rcpp.package.skeleton("RcppCorels")' + +Attaching package: ‘utils’ + +The following objects are masked from ‘package:Rcpp’: + + .DollarNames, prompt + +Creating directories ... +Creating DESCRIPTION ... +Creating NAMESPACE ... +Creating Read-and-delete-me ... +Saving functions and data ... +Making help files ... +Done. +Further steps are described in './RcppCorels/Read-and-delete-me'. + +Adding Rcpp settings + >> added Imports: Rcpp + >> added LinkingTo: Rcpp + >> added useDynLib directive to NAMESPACE + >> added importFrom(Rcpp, evalCpp) directive to NAMESPACE + >> added example src file using Rcpp attributes + >> added Rd file for rcpp_hello_world + >> compiled Rcpp attributes +edd@rob:~/git$ +edd@rob:~/git$ mv RcppCorels/ rcppcorels # prefer lowercase directories +edd@rob:~/git$ +``` + +## Appendix 2: A Minimal src/Makevars + +In the file shown here, use of GMP is unconditional: we define `GMP` as a compiler flag, and +instruct the linker to link with the GMP library. + +```sh + +CXX_STD = CXX11 + +PKG_CXXFLAGS = -I. -DGMP + +PKG_LIBS = $(LAPACK_LIBS) $(BLAS_LIBS) $(FLIBS) -lgmp + +``` + +## Appendix 3: A Placeholder Wrapper + +```c++ + +#include "queue.h" + +#include + +/* + * Logs statistics about the execution of the algorithm and dumps it to a file. + * To turn off, pass verbosity <= 1 + */ +NullLogger* logger; + +// [[Rcpp::export]] +bool corels() { + return true; // more to fill in, naturally +} +``` diff --git a/vignettes/Rcpp-modules.Rmd b/vignettes/rmd/Rcpp-modules.Rmd similarity index 64% rename from vignettes/Rcpp-modules.Rmd rename to vignettes/rmd/Rcpp-modules.Rmd index f934eb8b3..364e081a3 100644 --- a/vignettes/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++} @@ -154,10 +154,10 @@ functions such as the `norm` function shown above to \proglang{R}. We should note that \pkg{Rcpp} now has \textsl{Rcpp attributes} which extends certain aspect of \textsl{Rcpp modules} and makes binding to simple functions -such as this one even easier. With \textsl{Rcpp attribues} we can just write +such as this one even easier. With \textsl{Rcpp attributes} we can just write ```cpp -# include +#include // [[Rcpp::export]] double norm(double x, double y) { @@ -166,9 +166,9 @@ double norm(double x, double y) { ``` See the corresponding vignette \citep{CRAN:Rcpp:Attributes} for details, but -read on for \textsl{Rcpp modules} which contains to provide features not +read on for \textsl{Rcpp modules} which provide features not covered by \textsl{Rcpp attributes}, particularly when it comes to binding -entire C++ classes and more. +entire \proglang{C++} classes and more. ## Exposing classes using Rcpp @@ -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) { @@ -193,7 +193,7 @@ private: }; ``` -To use this class from R, we at least need to expose the constructor and +To use this class from \proglang{R}, we at least need to expose the constructor and the `draw` method. External pointers \citep{R:Extensions} are the perfect vessel for this, and using the `Rcpp:::XPtr` template from \pkg{Rcpp} we can expose the class @@ -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); @@ -240,7 +240,7 @@ they usually get wrapped as a slot of an S4 class. Using `cxxfunction()` from the \pkg{inline} package, we can build this example on the fly. Suppose the previous example code assigned to a text variable -`unifModcode`, we could then do +`unifModCode`, we could then do @@ -883,28 +1020,36 @@ TODO: mention R inheritance (John ?) The following example illustrates how to use Rcpp modules to expose the class `std::vector` from the STL. -```cpp -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 +// member functions vec::resize and vec::push_back +void vec_resize (vec* obj, int n) { + obj->resize(n); +} +void vec_push_back (vec* obj, double value) { + obj->push_back(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") @@ -915,11 +1060,9 @@ RCPP_MODULE(mod_vec) { // exposing member functions .method("size", &vec::size) .method("max_size", &vec::max_size) - .method("resize", &vec::resize) .method("capacity", &vec::capacity) .method("empty", &vec::empty) .method("reserve", &vec::reserve) - .method("push_back", &vec::push_back) .method("pop_back", &vec::pop_back) .method("clear", &vec::clear) @@ -928,11 +1071,13 @@ 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) + .method("resize", &vec_resize) + .method("push_back", &vec_push_back) .method("as.vector", &vec_asR) // special methods for indexing @@ -941,104 +1086,160 @@ RCPP_MODULE(mod_vec) { ; } ``` - ```{r, eval=FALSE} -# for code compiled on the fly using -# cxxfunction() into 'fx_vec', we use -mod_vec <- Module("mod_vec", - getDynLib(fx_vec), - mustStart = TRUE) +mod_vec <- Module("mod_vec", getDynLib(fx)) vec <- mod_vec$vec -# and that is not needed in a package -# setup as e.g. one created -# via Rcpp.package.skeleton(..., module=TRUE) v <- new(vec) v$reserve(50L) v$assign(1:10) v$push_back(10) v$size() +v$resize(30L) v$capacity() v[[ 0L ]] v$as.vector() ``` -# Using modules in other packages {#sec:package} +## Loading modules via sourceCpp {#sec:modules-sourceCpp} -## Namespace import/export +As an alternative to the explicit creation of a `Module` object using the +\pkg{inline} package via `cxxfunction` and `getDynLib`, it is possible to use +the `sourceCpp` function, accepting \proglang{C++} source code as either a +`.cpp` file or a character string and described in the \textsl{Rcpp attributes} +vignette \citep{CRAN:Rcpp:Attributes}. -### Import all functions and classes +The main differences with this approach are: -When using \pkg{Rcpp} modules in a packages, the client package needs to -import \pkg{Rcpp}'s namespace. This is achieved by adding the -following line to the `NAMESPACE` file. +- The `Rcpp.h` header file must be explicitly included. +- The content of the module (\proglang{C++} functions and classes) is +implicitly exposed and made available to \proglang{R} as individual objects, as +opposed to being accessed from a `Module` object with the `$` extractor. + +Note that this is similar to exposing modules in \proglang{R} packages using +`loadModule`, described in Section \ref{sec:package-namespace-loadModule} below. -```{r, echo=FALSE,eval=TRUE} -options( prompt = " ", continue = " " ) +As an example, consider a file called `yada.cpp` containing the following +\proglang{C++} code: + +```{Rcpp, eval=FALSE} +#include +std::string hello() { + return "hello"; +} +void bla() { + Rprintf("hello\\n"); +} +void bla2( int x, double y) { + Rprintf("hello (x = %d, y = %5.2f)\\n", x, y); +} + +class World { +public: + World() : msg("hello") {} + void set(std::string msg) { this->msg = msg; } + std::string greet() { return msg; } + +private: + std::string msg; +}; + +RCPP_MODULE(yada){ + using namespace Rcpp; + + function("hello" , &hello); + function("bla" , &bla); + function("bla2" , &bla2); + + class_("World") + .constructor() + .method("greet", &World::greet) + .method("set", &World::set) + ; +} ``` ```{r, eval=FALSE} -import(Rcpp) +sourceCpp('yada.cpp') ``` -In some case we have found that explicitly naming a symbol can be preferable: +\proglang{C++} functions `hello`, `bla`, `bla2` and class `World` will be +readily available in \proglang{R}: ```{r, eval=FALSE} -import(Rcpp, evalCpp) +hello() +bla() +bla2(42, 0.42) +w <- new(World) +w$greet() +w$set("hohoho") +w$greet() ``` -## Load the module -### Deprecated older method using loadRcppModules +# Using modules in other packages {#sec:package} -Note: This approach is deprecated as of Rcpp 0.12.5, and now triggers a warning -message. Eventually this function will be withdrawn. +## Namespace import -The simplest way to load all functions and classes from a module directly -into a package namespace used to be to use the `loadRcppModules` function -within the `.onLoad` body. +When using \textsl{Rcpp modules} in a packages, the client package needs to +import \pkg{Rcpp}'s namespace. This is achieved by adding the +following line to the `NAMESPACE` file. ```{r, eval=FALSE} -.onLoad <- function(libname, pkgname) { - loadRcppModules() -} +import(Rcpp) ``` -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, both the \pkg{testRcppModule} package -(which is part of large unit test suite for \pkg{Rcpp}) and the package -created via `Rcpp.package.skeleton("somename", module=TRUE)` have this -declaration: +In some case we have found that explicitly naming a symbol can be preferable: +```{r, eval=FALSE} +import(Rcpp, evalCpp) ``` -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. +## Load the module in the namespace + +### Load the module content via loadModule {#sec:package-namespace-loadModule} + +Starting with release 0.9.11, the preferred way for loading a module directly +into a package namespace is by calling the `loadModule()` function, which takes +the module name as an argument and exposes the content of the module +(\proglang{C++} functions and classes) as individual objects in the namespace. +It can be placed in any `.R` file in the package. This is useful as it allows to +load the module from the same file as some auxiliary \proglang{R} functions +using the module. -### Preferred current method using loadModule +Consider a package \pkg{testmod} defining a module `yada` in the source file +`src/yada.cpp`, with the same content as defined above in +Section \ref{sec:modules-sourceCpp} above -Starting with release 0.9.11, an alternative is provided by the -`loadModule()` function which takes the module name as an argument. -It can be placed in any `.R` file in the package. This is useful as it allows to load -the module from the same file as some auxiliary \proglang{R} functions using the -module. For the example module, the equivalent code to the `.onLoad()` -use shown above then becomes +Then, `loadModule` is called in the package's \proglang{R} code to expose all +\proglang{C++} functions and classes as objects `hello`, `bla`, `bla2`, `World` +into the package namespace: ```{r, eval=FALSE} -loadModule("yada") -loadModule("stdVector") -loadModule("NumEx") +loadModule("yada", TRUE) +``` + +Provided the objects are also exported (see Section \ref{sec:package-exports} below), this makes them readily +available in \proglang{R}: + +```{r, eval=FALSE} +library(testmod) +hello() +bla() +bla2(42, 0.42) +w <- new(World) +w$greet() +w$set("hohoho") +w$greet() ``` -This feature is also used in the new Rcpp Classes introduced with Rcpp 0.9.11. +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. ### Just expose the module -Alternatively, it is possible to just expose the module to the user of the package, +Alternatively to exposing a module's content via `loadModule`, +it is possible to just expose the module object to the users of the package, and let them extract the functions and classes as needed. This uses lazy loading so that the module is only loaded the first time the user attempts to extract a function or a class with the dollar extractor. @@ -1051,24 +1252,33 @@ yada <- Module( "yada" ) } ``` -```{r, echo=FALSE,eval=TRUE} -options(prompt = "> ", continue = "+ ") +Provided `yada` is properly exported, the functions and classes are +accessed as e.g. `yada$hello`, `yada$World`. + +## Namespace exports {#sec:package-exports} + +The content of modules or the modules as a whole, exposed as objects in the +package namespace, must be exported to be visible to users of the package. As +for any other object, this is achieved by the appropriate `export()` or +`exportPattern()` statements in the `NAMESPACE` file. For instance, the +functions and classes in the `yada` module considered above can be exported as: + +``` +export(hello, bla, bla2, World) ``` ## Support for modules in skeleton generator -The `Rcpp.package.skeleton` function has been improved to help -\pkg{Rcpp} modules. When the `module` argument is set to `TRUE`, -the skeleton generator installs code that uses a simple module. +Creating a new package using \textsl{Rcpp modules} is easiest via the call to +`Rcpp.package.skeleton()` with argument `module=TRUE`. ```{r, eval=FALSE} Rcpp.package.skeleton("testmod", module = TRUE) ``` -Creating a new package using \textsl{Rcpp modules} is easiest via the call to -`Rcpp.package.skeleton()` with argument `module=TRUE` as a working -package with three example Modules results. +This will install code providing three example modules, exposed using +`LoadModule`. ## Module documentation @@ -1090,7 +1300,7 @@ the `Module()` function as well. # Future extensions {#sec:future} `Boost.Python` has many more features that we would like to port -to Rcpp modules : class inheritance, default arguments, enum +to \textsl{Rcpp modules}: class inheritance, default arguments, enum types, ... # Known shortcomings {#sec:misfeatures} @@ -1100,9 +1310,9 @@ There are some things \textsl{Rcpp modules} is not good at: - serialization and deserialization of objects: modules are implemented via an external pointer using a memory location, which is non-constant and varies between session. Objects have to be re-created, - which is different from the (de-)serialization that R offers. So these + which is different from the (de-)serialization that \proglang{R} offers. So these objects cannot be saved from session to session. -- mulitple inheritance: currently, only simple class structures are +- multiple inheritance: currently, only simple class structures are representable via \textsl{Rcpp modules}. # Summary @@ -1111,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/Rcpp-package.Rmd b/vignettes/rmd/Rcpp-package.Rmd similarity index 94% rename from vignettes/Rcpp-package.Rmd rename to vignettes/rmd/Rcpp-package.Rmd index 2930d6622..0533c2b1f 100644 --- a/vignettes/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/Rcpp-quickref.Rmd b/vignettes/rmd/Rcpp-quickref.Rmd similarity index 93% rename from vignettes/Rcpp-quickref.Rmd rename to vignettes/rmd/Rcpp-quickref.Rmd index 772c431cd..2907427a5 100644 --- a/vignettes/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 @@ -111,7 +111,7 @@ NumericVector xx(y.begin(), y.end()); NumericVector xx = NumericVector::create(1.0, 2.0, 3.0, 4.0); NumericVector yy = - NumericVector::create(Named["foo"] = 1.0, + NumericVector::create(Named("foo") = 1.0, _["bar"] = 2.0); // _ short for Named ``` @@ -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. @@ -434,10 +434,6 @@ double zz = Rf_rnorm(0, 2); # Environment ```cpp -// Obtain an R environment -Environment stats("package:stats"); -Environment env( 2 ); // by position - // Special environments Environment::Rcpp_namespace(); Environment::base_env(); @@ -445,6 +441,11 @@ Environment::base_namespace(); Environment::global_env(); Environment::empty_env(); +// Obtain an R environment +Environment stats("package:stats"); +Environment env( 2 ); // by position +Environment glob = Environment::global_env(); + // Extract function from specific environment Function rnorm = stats["rnorm"]; @@ -457,7 +458,7 @@ std::string x = glob["x"]; glob.assign( "foo" , 3 ); int foo = glob.get( "foo" ); int foo = glob.find( "foo" ); -CharacterVector names = glob.ls() +CharacterVector names = glob.ls(TRUE) bool b = glob.exists( "foo" ); glob.remove( "foo" ); @@ -476,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"); @@ -484,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/Rcpp-sugar.Rmd b/vignettes/rmd/Rcpp-sugar.Rmd similarity index 92% rename from vignettes/Rcpp-sugar.Rmd rename to vignettes/rmd/Rcpp-sugar.Rmd index adcf7d59f..9384b78a9 100644 --- a/vignettes/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} @@ -137,7 +137,7 @@ high-level \proglang{R} syntax in \proglang{C++}. Hence, with \sugar, the \proglang{C++} version of `foo` now becomes: ```cpp -Rcpp::NumericVector foo(Rcpp::NumericVector x, +Rcpp::NumericVector foo(Rcpp::NumericVector x, Rcpp::NumericVector y) { return ifelse(x < y, x * x, -(y * y)); } @@ -308,7 +308,7 @@ length. Each element of the result expression evaluates to `TRUE` if the corresponding input is a missing value, or `FALSE` otherwise. ```cpp -IntegerVector x = +IntegerVector x = IntegerVector::create(0, 1, NA_INTEGER, 3); is_na(x) @@ -322,7 +322,7 @@ Given a sugar expression of any type, `seq_along` creates an integer sugar expression whose values go from 1 to the size of the input. ```cpp -IntegerVector x = +IntegerVector x = IntegerVector::create( 0, 1, NA_INTEGER, 3 ); IntegerVector y = seq_along(x); @@ -337,7 +337,7 @@ second expression, since the abstract syntax tree is built at compile time. ### seq_len -`seq_len` creates an integer sugar expression whose +`seq_len` creates an integer sugar expression whose \ith\ element expands to `i`. `seq_len` is particularly useful in conjunction with `sapply` and `lapply`. @@ -411,7 +411,7 @@ called `result_type` ```cpp template -struct square : std::unary_function { +struct square : std::function { T operator()(const T& x){ return x * x; } @@ -491,17 +491,17 @@ beta, binom, cauchy, chisq, exp, f, gamma, geom, hyper, lnorm, logis, nbeta, nbinom, nbinom_mu, nchisq, nf, norm, nt, pois, t, unif, and weibull. 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 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} +whereas the R-level \code{stats::rexp} is parameterized by \code{rate}. +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 @@ -568,13 +568,13 @@ is given here: template class VectorBase { public: - struct r_type : + struct r_type : traits::integral_constant{}; struct can_have_na : traits::integral_constant{}; - - typedef typename - traits::storage_type::type + + typedef typename + traits::storage_type::type stored_type; VECTOR& get_ref(){ @@ -586,18 +586,18 @@ public: this)->operator[](i); } - inline int size() const { + inline int size() const { return static_cast( - this)->size(); + this)->size(); } - /* definition ommited here */ + /* definition omitted here */ class iterator; - inline iterator begin() const { - return iterator(*this, 0); + inline iterator begin() const { + return iterator(*this, 0); } - inline iterator end() const { + inline iterator end() const { return iterator(*this, size()); } } @@ -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 @@ -633,27 +633,27 @@ the template class `Rcpp::sugar::Sapply` is given below: template class Sapply : public VectorBase< - Rcpp::traits::r_sexptype_traits< typename + Rcpp::traits::r_sexptype_traits< typename ::Rcpp::traits::result_of::type >::rtype, true, Sapply > { public: - typedef typename + typedef typename ::Rcpp::traits::result_of::type; - + const static int RESULT_R_TYPE = Rcpp::traits::r_sexptype_traits< result_type>::rtype; - + typedef Rcpp::VectorBase VEC; - - typedef typename + + typedef typename Rcpp::traits::r_vector_element_converter< RESULT_R_TYPE>::type converter_type; - + typedef typename Rcpp::traits::storage_type< RESULT_R_TYPE>::type STORAGE; @@ -663,9 +663,9 @@ public: inline STORAGE operator[]( int i ) const { return converter_type::get(fun(vec[i])); } - - inline int size() const { - return vec.size(); + + inline int size() const { + return vec.size(); } private: @@ -675,24 +675,22 @@ private: // sugar -template inline sugar::Sapply sapply(const Rcpp::VectorBase& t, Function fun) { - - return + + return sugar::Sapply(t, fun); } ``` ### The sapply function -`sapply` is a template function that takes two arguments. - -- The first argument is a sugar expression, which we recognize because of - the relationship with the `VectorBase` class template. -- The second argument is the function to apply. +`sapply` is a template function that takes two arguments. The first argument is a sugar +expression, which we recognize because of the relationship with the `VectorBase` class +template. The second argument is the function to apply. The `sapply` function itself does not do anything, it is just used to trigger compiler detection of the template parameters that will be used @@ -705,20 +703,21 @@ template class queries the template argument via the `Rcpp::traits::result_of` template. ```cpp -typedef typename - ::Rcpp::traits::result_of::type +typedef typename + ::Rcpp::traits::result_of::type result_type; ``` The `result_of` type trait is implemented as such: + ```{Rcpp, eval = FALSE} template struct result_of{ typedef typename T::result_type type; }; -template struct result_of { typedef RESULT_TYPE type; @@ -763,13 +762,13 @@ of a `REALSXP` expression is `double`. ```cpp typedef typename - Rcpp::traits::storage_type::type + Rcpp::traits::storage_type::type STORAGE; ``` ### Input expression base type -The input expression --- the expression over which `sapply` runs --- is +The input expression---the expression over which `sapply` runs---is also typedef'ed for convenience: ```cpp @@ -786,7 +785,7 @@ template class Sapply : public VectorBase< Rcpp::traits::r_sexptype_traits< - typename + typename ::Rcpp::traits::result_of::type >::rtype, true, @@ -800,12 +799,13 @@ is the manifestation of the _CRTP_. ### Constructor + The constructor of the `Sapply` class template is straightforward, it simply consists of holding the reference to the input expression and the function. ```cpp -Sapply(const VEC& vec_, Function fun_): +Sapply(const VEC& vec_, Function fun_): vec(vec_), fun(fun_){} private: @@ -825,8 +825,8 @@ and the converter. Both these methods are inline to maximize performance: inline STORAGE operator[](int i) const { return converter_type::get(fun(vec[i])); } -inline int size() const { - return vec.size(); +inline int size() const { + return vec.size(); } ``` diff --git a/vignettes/Rcpp.bib b/vignettes/rmd/Rcpp.bib similarity index 65% rename from vignettes/Rcpp.bib rename to vignettes/rmd/Rcpp.bib index 92f680009..4c2a6af37 100644 --- a/vignettes/Rcpp.bib +++ b/vignettes/rmd/Rcpp.bib @@ -1,15 +1,16 @@ -@String{CRAN = "http://CRAN.R-Project.org/" } +@String{CRAN = "https://CRAN.R-Project.org/" } @String{manuals = CRAN # "doc/manuals/" } @String{RCoreTeam = "{R Core Team}" } @String{RFoundation = "R Foundation for Statistical Computing" } -@String{R-Forge = "http://R-Forge.R-Project.org/" } +@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 = "http://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, @@ -39,7 +40,7 @@ @Manual{Armstrong:2009:RAbstraction author = {Whit Armstrong}, year = 2009, note = {Code repository last updated 2009-07-22.}, - url = {http://github.com/armstrtw/rabstraction} + url = {https://github.com/armstrtw/rabstraction} } @Manual{Armstrong:2009:RObjects, @@ -48,7 +49,7 @@ @Manual{Armstrong:2009:RObjects author = {Whit Armstrong}, year = 2009, note = {Code repository last updated 2009-11-28.}, - url = {http://github.com/armstrtw/RObjects} + url = {https://github.com/armstrtw/RObjects} } @InProceedings{Bates+DebRoy:2001:C++Classes, @@ -59,7 +60,7 @@ @InProceedings{Bates+DebRoy:2001:C++Classes Universit\"at Wien, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch}, year = {2001}, - url = {http://www.ci.tuwien.ac.at/Conferences/DSC-2001/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2001/Proceedings/}, note = {ISSN 1609-395X} } @@ -69,48 +70,81 @@ @Misc{Brokken:2011:Cpp title = {C++ Annotations}, howpublished = {Electronic book, University of Groningen}, year = 2011, - url = {http://www.icce.rug.nl/documents/cplusplus/} + url = {https://www.icce.rug.nl/documents/cplusplus/} +} + +@Manual{CRAN:anytime, + title = {anytime: Anything to 'POSIXct' or 'Date' Converter}, + author = {Dirk Eddelbuettel}, + 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 = {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 = 2018, - note = {R package version 1.2-14}, - url = CRAN # "package=Matrix" + year = 2025, + note = {R package version 1.7-4}, + 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 = 2017, - note = {R package version 0.2.14}, - 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 = 2018, - note = {R package version 0.4.12}, - 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}, - author = {Dirk Eddelbuettel and Khanh Nguyen}, - year = 2017, - note = {R package version 0.4.4}, - url = CRAN # "package=RQuantLib" + title = {RQuantLib: {R} Interface to the {QuantLib} Library}, + author = {Dirk Eddelbuettel and Khanh Nguyen and Terry Leitch}, + 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 = 2015, - note = {R package version 0.4.31}, - url = {https://CRAN.R-project.org/package=RUnit}, + year = 2024, + note = {R package version 0.4.33.1}, + oldurl = CRAN # "package=RUnit", + doi = DOI # "RUnit" } @Manual{CRAN:Rcpp, @@ -118,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 = 2018, - note = {R package version 0.12.19}, - url = CRAN # "package=Rcpp" + year = 2026, + note = {R package version 1.1.1}, + oldurl = CRAN # "package=Rcpp", + doi = DOI # "Rcpp" } @Manual{CRAN:Rcpp:Attributes, @@ -128,113 +163,163 @@ @Manual{CRAN:Rcpp:Attributes author = {J. J. Allaire and Dirk Eddelbuettel and Romain Fran\c{c}ois}, title = {{Rcpp} Attributes}, - year = 2018, + 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 = 2018, + 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 = 2026, + note = {Vignette included in R 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 = 2018, + 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 = 2018, + 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 = 2018, + 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}, - year = 2018, - note = {R package version 0.9.100.4.0}, - url = CRAN # "package=RcppArmadillo" + Douglas Bates and Binxiang Ni and Conrad Sanderson}, + 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 = 2024, + note = {R package version 0.2.13}, + oldurl = CRAN # "package=RcppCCTZ", + doi = DOI # "RcppCCTZ" } @Manual{CRAN:RcppClassic, title = {RcppClassic: Deprecated 'classic' Rcpp API}, author = {Dirk Eddelbuettel and Romain Fran\c{c}ois}, - year = 2018, - note = {R package version 0.9.11}, - url = CRAN # "package=RcppClassic" + year = 2022, + note = {R package version 0.9.13}, + 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 = 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 = 2018, - note = {R package version 0.1.6}, - url = CRAN # "package=RcppDE" + year = 2025, + note = {R package version 0.1.8}, + 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 = 2018, - note = {{R} package version 0.3.3.4.0}, - 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 = 2016, - note = {R package version 0.1.8}, - 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 = 2018, - note = {R package version 0.3.6}, - url = CRAN # "package=RcppGSL" + year = 2023, + note = {R package version 0.3.13}, + 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 = 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 = 2018, - note = {R package version 0.1.5}, - 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 = 2013, - note = {R package version 1.7-3}, - url = CRAN # "package=Rserve" + year = 2025, + note = {R package version 1.8-16}, + oldurl = CRAN # "package=Rserve", + doi = DOI # "Rserve" } @Manual{CRAN:cxxPack, @@ -243,68 +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 Winston Chang}, - year = 2016, - note = {R package version 1.12.0}, - url = {https://CRAN.R-project.org/package=devtools}, + author = {Hadley Wickham and Jim Hester and Winston Chang}, + year = 2025, + note = {R package version 2.4.6}, + oldurl = CRAN # "package=devtools", + doi = DOI # "devtools" } @Manual{CRAN:highlight, - title = {highlight: Syntax highlighter}, - author = {Romain Fran\c{c}ois}, - year = 2017, - note = {R package with version 0.4.7.2}, - url = CRAN # "package=highlight" + title = {highlight: Syntax Highlighter}, + author = {Hadley Wickham and Romain Fran\c{c}ois and Andre Simon}, + 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}, - year = 2015, - note = {R package version 0.3.14}, - url = CRAN # "package=inline" + 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 = 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 = 2017, - note = {R package version 0.3.2}, - 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 = 2015, - note = {R package version 1.4-2.1}, - url = {https://CRAN.R-project.org/package=microbenchmark} + year = 2023, + 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 = 2014, - note = {R package version 1.2.4}, - 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 = {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}, - year = 2017, - note = {R package version 0.3.3}, - url = {https://CRAN.R-project.org/package=profvis}, + author = {Winston Chang and Javier Luraschi and and Timothy Mastny}, + year = 2024, + note = {R package version 0.4.0}, + oldurl = CRAN # "package=profvis", + doi = DOI # "profvis" } @Manual{CRAN:rbenchmark, @@ -312,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}, - author = {Hadley Wickham and Peter Danenberg and Manuel Eugster}, - year = 2017, - note = {R package version 6.0.1}, - url = CRAN # "package=roxygen2" + title = {roxygen2: In-Line documentation for R}, + author = {Hadley Wickham and Peter Danenberg and G\a'bor Cs\a'rdi and Manuel Eugster}, + year = 2025, + note = {R package version 7.3.3}, + oldurl = CRAN # "package=roxygen2", + doi = DOI # "roxygen2" } @Article{CRAN:testthat, @@ -361,14 +467,33 @@ @Book{Chambers:2016:ExtR note = {{ISBN} 9781498775717} } +@Article{Chambers:2020:S+R+DS, + author = {Chambers, John M.}, + title = {S, R, and Data Science}, + year = 2020, + issue_date = {June 2020}, + publisher = {Association for Computing Machinery}, + address = {New York, NY, USA}, + volume = 4, + number = {HOPL}, + url = {https://doi.org/10.1145/3386334}, + doi = {10.1145/3386334}, + journal = {Proceeding of the ACM on Programming Languages}, + month = jun, + articleno = 84, + numpages = 17, + keywords = {data science, statistical computing, scientific + computing} +} + @Misc{Cpp11, author = "ISO/IEC", organization = "{International Organization for Standardization}", title = "\proglang{C++} 2011 Standard Document 14882:2011", howpublished = {ISO/IEC Standard Group for Information Technology / Programming Languages / C++}, year = 2011, - url = "http://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372", - urlansi = "http://webstore.ansi.org/RecordDetail.aspx?sku=ISO/IEC%2014882:2011" + url = "https://www.iso.org/iso/iso_catalogue/catalogue_tc/catalogue_detail.htm?csnumber=50372", + urlansi = "https://webstore.ansi.org/RecordDetail.aspx?sku=ISO/IEC%2014882:2011" } @book{Dongarra:1979:UGLINPACK, @@ -388,7 +513,7 @@ @Article{Eddelbuettel+Sanderson:2013:RcppArmadillo month = {March}, pages = {1054--1063}, doi = {10.1016/j.csda.2013.02.005}, - url = {http://dx.doi.org/10.1016/j.csda.2013.02.005} + url = {https://dx.doi.org/10.1016/j.csda.2013.02.005} } @Article{Eddelbuettel+Sanderson:2014:RcppArmadillo, @@ -400,7 +525,7 @@ @Article{Eddelbuettel+Sanderson:2014:RcppArmadillo month = {March}, pages = {1054--1063}, doi = {10.1016/j.csda.2013.02.005}, - url = {http://dx.doi.org/10.1016/j.csda.2013.02.005} + url = {https://dx.doi.org/10.1016/j.csda.2013.02.005} } @Book{Eddelbuettel:2013:Rcpp, @@ -414,7 +539,7 @@ @Book{Eddelbuettel:2013:Rcpp } @article{Efron:1979:Bootstrap, - URL = {http://www.jstor.org/stable/2958830}, + URL = {https://www.jstor.org/stable/2958830}, author = {Efron, B.}, journal = {The Annals of Statistics}, number = {1}, @@ -429,10 +554,8 @@ @MISC{Eigen:Web author = {Ga\"{e}l Guennebaud and Beno\^{i}t Jacob and others}, title = {Eigen v3}, year = 2012, - url = {http://eigen.tuxfamily.org}, + url = {https://libeigen.gitlib.io/} } -; see http://eigen.tuxfamily.org/index.php?title=BibTeX -; replaced 'howpublished' with 'url' and updated year to 2011, and again to 2012 @Manual{GSL, title = {{GNU} {S}cientific {L}ibrary {R}eference {M}anual}, @@ -440,7 +563,7 @@ @Manual{GSL year = {2010}, edition = {3rd}, note = {Version 1.14. {ISBN} 0954612078}, - url = {http://www.gnu.org/software/gsl} + url = {https://www.gnu.org/software/gsl} } @Book{Gentleman:2009:RProgramming, @@ -464,7 +587,8 @@ @Article{Gropp+Lusk+Doss+Skjellum:1996:MPI title = {A high-performance, portable implementation of the {MPI} message passing interface standard}, journal = {Parallel Computing}, year = 1996, - url = {http://dx.doi.org/10.1016/0167-8191(96)00024-5}, + url = {https://dx.doi.org/10.1016/0167-8191(96)00024-5}, + doi = {10.1016/0167-8191(96)00024-5}, volume = 22, number = 6, pages = {789--828} @@ -513,7 +637,8 @@ @Article{JSS:RProtoBuf volume = {71}, number = {2}, pages = {1--24}, - doi = {10.18637/jss.v071.i02}, + url = {https://doi.org/10.18637/jss.v071.i02}, + doi = {10.18637/jss.v071.i02} } @Article{JSS:Rcpp, @@ -524,7 +649,8 @@ @Article{JSS:Rcpp volume = 40, number = 8, pages = {1--18}, - url = {http://www.jstatsoft.org/v40/i08/}, + url = {https://doi.org/10.18637/jss.v040.i08}, + doi = {10.18637/jss.v040.i08} } @Article{JSS:RcppEigen, @@ -536,7 +662,8 @@ @Article{JSS:RcppEigen volume = {52}, number = {5}, pages = {1--24}, - url = {http://www.jstatsoft.org/v52/i05/}, + url = {https://doi.org/10.18637/jss.v052.i05}, + doi = {10.18637/jss.v052.i05} } @Unpublished{Java+Gaile+Manly:2007:RCpp, @@ -546,7 +673,7 @@ @Unpublished{Java+Gaile+Manly:2007:RCpp Objects in {C++} Extensions}, note = {Unpublished manuscript, University at Buffalo}, url = - {http://sphhp.buffalo.edu/biostat/research/techreports/UB_Biostatistics_TR0702.pdf}, + {https://sphhp.buffalo.edu/biostat/research/techreports/UB_Biostatistics_TR0702.pdf}, month = {July}, year = 2007 } @@ -554,7 +681,7 @@ @Unpublished{Java+Gaile+Manly:2007:RCpp @misc{KDE-TechBase:2012, author = {KDE-TechBase}, title = {Binary Compatibility Issues With {C++}}, - url = "http://techbase.kde.org/Policies/Binary_Compatibility_Issues_With_C++", + url = "https://techbase.kde.org/Policies/Binary_Compatibility_Issues_With_C++", year = 2012, note = "[Online; accessed 24-November-2012]" } @@ -603,7 +730,7 @@ @InProceedings{Maurer+Wong:2008:AttributesInC++ booktitle = {JTC1/SC22/WG21 - The C++ Standards Committee}, year = {2008}, url = - {http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}, + {https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2761.pdf}, note = {{N2761=08-0271}} } @@ -646,7 +773,8 @@ @Article{PeerJ:Rcpp issue = {e3188v1}, year = 2017, month = {August}, - doi = {10.7287/peerj.preprints.3188v1/}, + url = {https://peerj.com/preprints/3188v1/}, + doi = {10.7287/peerj.preprints.3188v1} } @Book{Plauger+Et+Al:2000:STL, @@ -655,16 +783,24 @@ @Book{Plauger+Et+Al:2000:STL title = {The {C++} Standard Template Library}, publisher = {Prentice Hall PTR}, year = 2000, - note = {{ISBN} 978-0134376332}, + note = {{ISBN} 978-0134376332} +} + +@manual{QuantLib, + author = {{QuantLib Core Team}}, + year = 2021, + title = {QuantLib: a free/open-source library for quantitative finance}, + url = {https://www.quantlib.org} } @manual{R:Administration, author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "R Installation and Administration", annote = {{ISBN} 3-900051-09-7}, + doi = "10.32614/R.manuals", url = manuals # "R-admin.html" } @@ -672,9 +808,10 @@ @manual{R:Extensions author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "Writing R extensions", annote = {{ISBN} 3-900051-11-9}, + doi = "10.32614/R.manuals", url = manuals # "R-exts.html" } @@ -682,9 +819,10 @@ @manual{R:Internals author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "R internals", annote = {{ISBN} 3-900051-14-3}, + doi = "10.32614/R.manuals", url = manuals # "R-ints.html" } @@ -692,9 +830,10 @@ @manual{R:Language author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, title = "R language", annote = {{ISBN} 3-900051-13-5}, + doi = "10.32614/R.manuals", url = manuals # "R-lang.html" } @@ -704,7 +843,8 @@ @Manual{R:Main author = RCoreTeam, organization = RFoundation, address = {Vienna, Austria}, - year = 2018, + year = 2025, + doi = "10.32614/R.manuals", url = {https://www.R-project.org/} } @@ -727,7 +867,7 @@ @Manual{Samperi:2009:RcppTemplate @article{Sanderson+Curtin:2016, doi = {10.21105/joss.00026}, - url = {http://dx.doi.org/10.21105/joss.00026}, + url = {https://dx.doi.org/10.21105/joss.00026}, year = 2016, month = {{June}}, publisher = {The Open Journal}, @@ -746,7 +886,7 @@ @TechReport{Sanderson:2010:Armadillo Experiments }, institution = {{NICTA}}, year = 2010, - url = "http://arma.sf.net" + url = "https://arma.sourceforge.net" } @Book{Stroustrup:1997:Cpp, @@ -776,6 +916,7 @@ @Article{TAS:Rcpp number = 1, year = 2018, month = {August}, + url = {https://doi.org/10.1080/00031305.2017.1375990}, doi = {10.1080/00031305.2017.1375990} } @@ -811,7 +952,7 @@ @InProceedings{Urbanek:2003:Rserve Statistical Computing, Vienna, Austria}, editor = {Kurt Hornik and Friedrich Leisch and Achim Zeileis}, year = {2003}, - url = {http://www.ci.tuwien.ac.at/Conferences/DSC-2003/Proceedings/}, + url = {https://www.r-project.org/conferences/DSC-2003/Proceedings/}, note = {{ISSN 1609-395X}} } @@ -836,6 +977,7 @@ @inproceedings{Veldhuizen:1998:Blitz address = {London}, } + @Book{Venables+Ripley:2000:SProgramming, author = {Willian N. Venables and Brian D. Ripley}, title = {S Programming}, @@ -845,6 +987,7 @@ @Book{Venables+Ripley:2000:SProgramming address = {New York} } + @Book{Venables+Ripley:2002:MASS, title = {Modern Applied Statistics with S}, author = {W. N. Venables and B. D. Ripley}, @@ -853,5 +996,32 @@ @Book{Venables+Ripley:2002:MASS address = {New York}, year = 2002, note = {ISBN 0-387-95457-0}, - url = {http://www.stats.ox.ac.uk/pub/MASS4}, + url = {https://www.stats.ox.ac.uk/pub/MASS4/}, +} + +@misc{arxiv:corels, + title = {Learning Certifiably Optimal Rule Lists for + Categorical Data}, + author = {Elaine Angelino and Nicholas Larus-Stone and Daniel + Alabi and Margo Seltzer and Cynthia Rudin}, + year = 2017, + howpublished = {\href{https://www.arxiv.org/abs/1704.01701}{arXiv:1704.01701}}, + archivePrefix ={arXiv}, + primaryClass = {stat.ML} +} + +@Misc{github:corels, + author = {Nicholas Laurus-Stone}, + title = {corels: {Learning Certifiably Optimal Rule Lists}}, + 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 +} + +@Misc{github:rcppcorels, + author = {Dirk Eddelbuettel}, + title = {RcppCorels: R binding for the 'Certifiably Optimal RulE ListS (Corels)' Learner}, + howpublished = {\url{https://github.com/corels/rcppcorels}}, + month = 11, + year = 2019 } diff --git a/vignettes/rmd/figures/bootstrap.pdf b/vignettes/rmd/figures/bootstrap.pdf new file mode 100644 index 000000000..f7e530bb5 Binary files /dev/null and b/vignettes/rmd/figures/bootstrap.pdf differ diff --git a/vignettes/figures/dist_graphs-1.pdf b/vignettes/rmd/figures/dist_graphs-1.pdf similarity index 100% rename from vignettes/figures/dist_graphs-1.pdf rename to vignettes/rmd/figures/dist_graphs-1.pdf diff --git a/vignettes/figures/function_annotation_cpp.png b/vignettes/rmd/figures/function_annotation_cpp.png similarity index 100% rename from vignettes/figures/function_annotation_cpp.png rename to vignettes/rmd/figures/function_annotation_cpp.png diff --git a/vignettes/figures/samplePkg-files-light-bg.png b/vignettes/rmd/figures/samplePkg-files-light-bg.png similarity index 100% rename from vignettes/figures/samplePkg-files-light-bg.png rename to vignettes/rmd/figures/samplePkg-files-light-bg.png diff --git a/vignettes/rmd/getCurrentVersionsOfCitedPackages.R b/vignettes/rmd/getCurrentVersionsOfCitedPackages.R new file mode 100755 index 000000000..f7d265d57 --- /dev/null +++ b/vignettes/rmd/getCurrentVersionsOfCitedPackages.R @@ -0,0 +1,17 @@ +#!/usr/bin/r + +stopifnot(`Needs data.table` = requireNamespace("data.table", quietly = TRUE)) +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)}' | sed -e 's/,$//' - | sort -f | uniq" +con <- pipe(cmd) +pkgs <- readLines(con) +close(con) + +pkg <- data.table(Package=pkgs) + +db <- data.table(tools::CRAN_package_db()) + +print(db[pkg, on="Package"][, .(Package, Version, Date, Title)]) diff --git a/vignettes/jss.bst b/vignettes/rmd/jss.bst similarity index 100% rename from vignettes/jss.bst rename to vignettes/rmd/jss.bst diff --git a/vignettes/notyet/Rcpp-api.Rnw b/vignettes/rmd/notyet/Rcpp-api.Rnw similarity index 100% rename from vignettes/notyet/Rcpp-api.Rnw rename to vignettes/rmd/notyet/Rcpp-api.Rnw diff --git a/vignettes/notyet/Rcpp-unitTests.Rnw b/vignettes/rmd/notyet/Rcpp-unitTests.Rnw similarity index 100% rename from vignettes/notyet/Rcpp-unitTests.Rnw rename to vignettes/rmd/notyet/Rcpp-unitTests.Rnw