diff --git a/.clang-format b/.clang-format new file mode 100644 index 00000000..b1a077af --- /dev/null +++ b/.clang-format @@ -0,0 +1,14 @@ +BasedOnStyle: Mozilla +Standard: Cpp11 +AlignAfterOpenBracket: false +AlignEscapedNewlinesLeft: true +AlwaysBreakAfterDefinitionReturnType: None +BreakBeforeBraces: Allman +BreakConstructorInitializersBeforeComma: false +ColumnLimit: 100 +ConstructorInitializerAllOnOneLineOrOnePerLine: true +ConstructorInitializerIndentWidth: 0 +IndentCaseLabels: false +SortIncludes: false +AlignTrailingComments: false + diff --git a/.github/workflows/autotools-clang.yml b/.github/workflows/autotools-clang.yml new file mode 100644 index 00000000..756baf23 --- /dev/null +++ b/.github/workflows/autotools-clang.yml @@ -0,0 +1,27 @@ +name: "Autotools: clang" + +on: [push] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Build + run: | + # Prevent blocking apt install on a question during configuring of tzdata. + export ENV DEBIAN_FRONTEND=noninteractive + sudo apt update + sudo apt install mm-common clang make docbook-xsl --yes + export CC=clang CXX=clang++ + ./autogen.sh --enable-warnings=fatal + make + - name: Test + run: make check + - name: Distcheck + run: | + # distcheck runs configure again so we need to specify CC and CXX again. + export CC=clang CXX=clang++ + make distcheck diff --git a/.github/workflows/autotools-gcc.yml b/.github/workflows/autotools-gcc.yml new file mode 100644 index 00000000..018fdc1a --- /dev/null +++ b/.github/workflows/autotools-gcc.yml @@ -0,0 +1,27 @@ +name: "Autotools: gcc" + +on: [push] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Build + run: | + # Prevent blocking apt install on a question during configuring of tzdata. + export ENV DEBIAN_FRONTEND=noninteractive + sudo apt update + sudo apt install mm-common g++ make docbook-xsl --yes + export CXX=g++ + ./autogen.sh --enable-warnings=fatal + make + - name: Test + run: make check + - name: Distcheck + run: | + # distcheck runs configure again so we need to specify CXX again. + export CXX=g++ + make distcheck diff --git a/.github/workflows/clang-format-check.yml b/.github/workflows/clang-format-check.yml new file mode 100644 index 00000000..ffe78737 --- /dev/null +++ b/.github/workflows/clang-format-check.yml @@ -0,0 +1,19 @@ +name: "Check Code Formatting" + +# Triggered manually +on: [workflow_dispatch] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Check Code Formatting + run: | + # Prevent blocking the install on a question during configuring of tzdata. + export ENV DEBIAN_FRONTEND=noninteractive + sudo apt update + sudo apt install clang-format --yes + clang-format --dry-run --Werror `find . -name "*.h" -or -name "*.cc"` diff --git a/.github/workflows/cmake-msvc.yml b/.github/workflows/cmake-msvc.yml new file mode 100644 index 00000000..88a93323 --- /dev/null +++ b/.github/workflows/cmake-msvc.yml @@ -0,0 +1,19 @@ +name: "CMake: MSVC" + +# Triggered manually +on: [workflow_dispatch] + +jobs: + build: + + runs-on: windows-latest + + steps: + - uses: actions/checkout@v1 + - uses: microsoft/setup-msbuild@v1 + - name: Build + run: | + cmake . + msbuild ALL_BUILD.vcxproj + - name: Test + run: msbuild RUN_TESTS.vcxproj diff --git a/.github/workflows/cmake.yml b/.github/workflows/cmake.yml new file mode 100644 index 00000000..470b5b76 --- /dev/null +++ b/.github/workflows/cmake.yml @@ -0,0 +1,17 @@ +name: "CMake: gcc" + +on: [push] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Build + run: | + cmake . + make + - name: Test + run: make test diff --git a/.github/workflows/meson-clang.yml b/.github/workflows/meson-clang.yml new file mode 100644 index 00000000..660a7010 --- /dev/null +++ b/.github/workflows/meson-clang.yml @@ -0,0 +1,37 @@ +# 2024-07-19: ubuntu-latest = ubuntu-22.04 +# See https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/about-github-hosted-runners#standard-github-hosted-runners-for-public-repositories +name: "Meson: clang" + +on: [push] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Build + run: | + # Prevent blocking apt install on a question during configuring of tzdata. + export ENV DEBIAN_FRONTEND=noninteractive + sudo apt update + sudo apt install libxml2-utils docbook5-xml docbook-xsl mm-common clang ninja-build python3-setuptools python3-pip --yes + # Ubuntu 22.04 contains meson 0.61.2, but libsigc++ requires meson >= 0.62.0. + # Install it with pip instead of apt. + sudo pip install "meson>=0.62.0" + export CXX=clang++ + meson setup -Dwarnings=fatal -Dwarning_level=3 -Dwerror=true _build + cd _build + meson compile + - name: Test + run: | + cd _build + meson test + - name: Dist + run: | + sudo apt install git --yes + # dist runs setup again so we need to specify CXX again. + export CXX=clang++ + cd _build + meson dist diff --git a/.github/workflows/meson-gcc.yml b/.github/workflows/meson-gcc.yml new file mode 100644 index 00000000..fe2ba8ae --- /dev/null +++ b/.github/workflows/meson-gcc.yml @@ -0,0 +1,37 @@ +# 2024-07-19: ubuntu-latest = ubuntu-22.04 +# See https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/about-github-hosted-runners#standard-github-hosted-runners-for-public-repositories +name: "Meson: gcc" + +on: [push] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v1 + - name: Build + run: | + # Prevent blocking apt install on a question during configuring of tzdata. + export ENV DEBIAN_FRONTEND=noninteractive + sudo apt update + sudo apt install libxml2-utils docbook5-xml docbook-xsl mm-common g++ ninja-build python3-setuptools python3-pip --yes + # Ubuntu 22.04 contains meson 0.61.2, but libsigc++ requires meson >= 0.62.0. + # Install it with pip instead of apt. + sudo pip install "meson>=0.62.0" + export CXX=g++ + meson setup -Dwarnings=fatal -Dwarning_level=3 -Dwerror=true _build + cd _build + meson compile + - name: Test + run: | + cd _build + meson test + - name: Dist + run: | + sudo apt install git --yes + # dist runs setup again so we need to specify CXX again. + export CXX=g++ + cd _build + meson dist diff --git a/.github/workflows/meson-msvc.yml b/.github/workflows/meson-msvc.yml new file mode 100644 index 00000000..a9aef1a1 --- /dev/null +++ b/.github/workflows/meson-msvc.yml @@ -0,0 +1,35 @@ +name: "Meson: MSVC" + +on: [push] + +jobs: + build: + + runs-on: windows-latest + + steps: + - uses: actions/checkout@v3 + - uses: ssciwr/doxygen-install@v1 + - uses: actions/setup-python@v4 + with: + python-version: '3.x' + - run: pip install meson ninja + + - name: Prepare MSVC + uses: bus1/cabuild/action/msdevshell@v1 + with: + architecture: x64 + + - name: Configure + # Don't use warning_level or werror. They are applied also to subprojects. + # With the latest fixes in mm-common and libsigc++ it's possible + # to build the reference documentation, but it's error-prone to build + # the manual. AFAIK there are no easily installable docbook5-xml and + # docbook-xsl packages for Windows. + run: meson setup -Dwarnings=fatal -Dbuild-manual=false -Dmm-common:use-network=true _build + + - name: Compile + run: meson compile -C _build + + - name: Test + run: meson test -C _build diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml new file mode 100644 index 00000000..6d450fe4 --- /dev/null +++ b/.github/workflows/publish-docs.yml @@ -0,0 +1,79 @@ +# Sample workflow for building and deploying a Jekyll site to GitHub Pages + +# Copied from https://github.com/libsigcplusplus/libsigcplusplus/actions/new +# and changed. Actions -> New workflow -> Pages -> GitHub Pages Jekyll + +name: Publish docs + +# 2025-02-05: ubuntu-latest = ubuntu-24.04 +# See https://docs.github.com/en/actions/using-github-hosted-runners/about-github-hosted-runners/about-github-hosted-runners#standard-github-hosted-runners-for-public-repositories +on: + # Runs on pushes targeting the default branch + push: + branches: ["master"] + + # Allows you to run this workflow manually from the Actions tab + workflow_dispatch: + +# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages +permissions: + contents: read + pages: write + id-token: write + +# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued. +# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete. +concurrency: + group: "pages" + cancel-in-progress: false + +jobs: + # Build job + build: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Build + run: | + # Prevent blocking apt install on a question during configuring of tzdata. + export ENV DEBIAN_FRONTEND=noninteractive + sudo apt update + sudo apt install libxml2-utils docbook5-xml docbook-xsl mm-common g++ meson ninja-build python3-setuptools python3-pip --yes + meson setup -Dbuild-documentation=true -Dbuild-examples=false -Dbuild-tests=false _build + meson compile -C _build + - name: Collect Documentation + # Collect all documentation to be published. + run: | + mkdir _publish _publish/_layouts _publish/pix _publish/manual _publish/reference + # Copy files from the git repository. + cp docs/_config.yml docs/*.md docs/style.css _publish + cp docs/_layouts/*.html _publish/_layouts + cp docs/pix/logo.gif _publish/pix + # Move generated documentation. + mv _build/docs/docs/manual/html _publish/manual + mv _build/docs/docs/reference/html _publish/reference + mv _build/docs/docs/reference/*.tag _publish/reference/html + - name: Setup Pages + uses: actions/configure-pages@v5 + - name: Build with Jekyll + uses: actions/jekyll-build-pages@v1 + with: + source: ./_publish + destination: ./_site + - name: Upload artifact + uses: actions/upload-pages-artifact@v3 + + # Deployment job + # Publish documentation at https://libsigcplusplus.github.io/libsigcplusplus/ + deploy: + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + runs-on: ubuntu-latest + needs: build + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v4 + diff --git a/.gitignore b/.gitignore index 14155c15..c55c4a07 100644 --- a/.gitignore +++ b/.gitignore @@ -7,8 +7,9 @@ Makefile.in *.l[ao] *~ /INSTALL -/MSVC_Net201?/sigc.rc -/MSVC_Net201?/sigc++config.h +/MSVC_NMake/sigc.rc +/MSVC_NMake/sigc++config.h +/build/compile /aclocal.m4 /autom4te.cache/ /config.h @@ -23,3 +24,6 @@ Makefile.in /sigc++config.h /sigc++-*.pc /stamp-h? +untracked/build_scripts/ +untracked/docs/ +*.pro.user diff --git a/AUTHORS b/AUTHORS deleted file mode 100644 index 000671ac..00000000 --- a/AUTHORS +++ /dev/null @@ -1,8 +0,0 @@ -Martin Schulze -Murray Cumming -Cedric Gustin (win32 support) -Timothy M. Shead and James Lin (MSVC support) -Damien Carbery (Sun FORTE C++ support) -Takashi Takekawa (Intel C++ support) -Andreas Rottmann (make system) -Karl Einar Nelson (initial version 1.9.4) diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 00000000..ee64a3a4 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,125 @@ +# Copyright 2016, The libsigc++ Development Team +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library 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 +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, see . + +cmake_minimum_required (VERSION 3.10) + +set (SIGCXX_MAJOR_VERSION 3) +set (SIGCXX_MINOR_VERSION 4) +set (SIGCXX_MICRO_VERSION 0) + +set (SIGCXX_API_VERSION 3.0) +set (PACKAGE_VERSION ${SIGCXX_MAJOR_VERSION}.${SIGCXX_MINOR_VERSION}.${SIGCXX_MICRO_VERSION}) +set (LIBSIGCPP_SOVERSION 0) +set (MSVC_STATIC_CXXFLAG "") + +option (SIGCXX_DISABLE_DEPRECATED "Disable deprecated" OFF) + +project (sigc++) + +set( CMAKE_CXX_STANDARD 17 ) + +# Turn on warnings for MSVC. Remove the CMake default of /W3 because when you +# add /W4, MSVC will complain about two warning level flags. This default +# changed at CMake 3.15 (see +# https://cmake.org/cmake/help/v3.15/policy/CMP0092.html#policy:CMP0092 for +# more details) + if (MSVC AND CMAKE_VERSION VERSION_LESS "13.15") + string(REGEX REPLACE "(^|[ \t])/W[0-9]($|[ \t])" "\\1\\2" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") + string(REGEX REPLACE "(^|[ \t])/W[0-9]($|[ \t])" "\\1\\2" CMAKE_CXX_FLAGS + "${CMAKE_CXX_FLAGS}") +endif() + +# Add compiler warning flags & turn warnings into errors +add_compile_options( + "$<$,$>:/W4;/WX>" + "$<$,$>:-pedantic;-Wall;-Wextra;-Wsuggest-override;-Wshadow;-Wzero-as-null-pointer-constant;-Wformat-security>" + "$<$,$,$,$>:-pedantic;-Wall;-Wextra;-Wshadow;-Wzero-as-null-pointer-constant;-Wformat-security>" +) + +set (PROJECT_SOURCE_DIR "${sigc++_SOURCE_DIR}/sigc++") + +include_directories (${sigc++_SOURCE_DIR}) +include_directories (${sigc++_BINARY_DIR}) + +configure_file (sigc++config.h.cmake sigc++config.h) + +set (prefix ${CMAKE_INSTALL_PREFIX}) +set (exec_prefix \${prefix}) +set (libdir \${exec_prefix}/lib) +set (datarootdir \${prefix}) +set (datadir \${datarootdir}) +set (includedir \${prefix}/include) +set (top_srcdir .) +configure_file (sigc++.pc.in sigc++-${SIGCXX_API_VERSION}.pc @ONLY) +configure_file (sigc++-uninstalled.pc.in sigc++-${SIGCXX_API_VERSION}-uninstalled.pc @ONLY) + +if (NOT TARGET uninstall) +configure_file( + "${CMAKE_CURRENT_SOURCE_DIR}/cmake_uninstall.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" + IMMEDIATE @ONLY) + +add_custom_target(uninstall + COMMAND ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) +endif() + +install (FILES + "${CMAKE_CURRENT_BINARY_DIR}/sigc++config.h" + DESTINATION + "${CMAKE_INSTALL_PREFIX}/lib/${PROJECT_NAME}-${SIGCXX_API_VERSION}/include") + +install (FILES + "${CMAKE_CURRENT_BINARY_DIR}/sigc++-${SIGCXX_API_VERSION}.pc" + DESTINATION + "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig") + +enable_testing() + + + +add_subdirectory (sigc++) +add_subdirectory (examples) +add_subdirectory (tests) + + +set (PROJECT_CMAKE_NAME "${PROJECT_NAME}-3") +set (VERSION_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_CMAKE_NAME}ConfigVersion.cmake") +set (LIBSIGCXX_INCLUDE_DIR "${CMAKE_INSTALL_PREFIX}/lib/${PROJECT_NAME}-${SIGCXX_API_VERSION}/include") +set (PROJECT_CONFIG "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_CMAKE_NAME}Config.cmake") +set (CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_CMAKE_NAME}") +set (TARGETS_EXPORT_NAME "${PROJECT_CMAKE_NAME}Targets") +include (CMakePackageConfigHelpers) + +write_basic_package_version_file ( + "${VERSION_CONFIG}" + VERSION ${PACKAGE_VERSION} + COMPATIBILITY SameMajorVersion +) + +configure_package_config_file ( + "cmake/sigc++-3Config.cmake.in" + "${PROJECT_CONFIG}" + INSTALL_DESTINATION "${CONFIG_INSTALL_DIR}" +) + +install ( + FILES "${PROJECT_CONFIG}" "${VERSION_CONFIG}" + DESTINATION "${CONFIG_INSTALL_DIR}" +) + +install ( + EXPORT "${TARGETS_EXPORT_NAME}" + DESTINATION "${CONFIG_INSTALL_DIR}" +) diff --git a/COPYING b/COPYING index c4792dd2..341c30bd 100644 --- a/COPYING +++ b/COPYING @@ -1,515 +1,166 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 - - Copyright (C) 1991, 1999 Free Software Foundation, Inc. - 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. -[This is the first released version of the Lesser GPL. It also counts - as the successor of the GNU Library Public License, version 2, hence - the version number 2.1.] - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -Licenses are intended to guarantee your freedom to share and change -free software--to make sure the software is free for all its users. - - This license, the Lesser General Public License, applies to some -specially designated software packages--typically libraries--of the -Free Software Foundation and other authors who decide to use it. You -can use it too, but we suggest you first think carefully about whether -this license or the ordinary General Public License is the better -strategy to use in any particular case, based on the explanations -below. - - When we speak of free software, we are referring to freedom of use, -not price. Our General Public Licenses are designed to make sure that -you have the freedom to distribute copies of free software (and charge -for this service if you wish); that you receive source code or can get -it if you want it; that you can change the software and use pieces of -it in new free programs; and that you are informed that you can do -these things. - - To protect your rights, we need to make restrictions that forbid -distributors to deny you these rights or to ask you to surrender these -rights. These restrictions translate to certain responsibilities for -you if you distribute copies of the library or if you modify it. - - For example, if you distribute copies of the library, whether gratis -or for a fee, you must give the recipients all the rights that we gave -you. You must make sure that they, too, receive or can get the source -code. If you link other code with the library, you must provide -complete object files to the recipients, so that they can relink them -with the library after making changes to the library and recompiling -it. And you must show them these terms so they know their rights. - - We protect your rights with a two-step method: (1) we copyright the -library, and (2) we offer you this license, which gives you legal -permission to copy, distribute and/or modify the library. - - To protect each distributor, we want to make it very clear that -there is no warranty for the free library. Also, if the library is -modified by someone else and passed on, the recipients should know -that what they have is not the original version, so that the original -author's reputation will not be affected by problems that might be -introduced by others. -^L - Finally, software patents pose a constant threat to the existence of -any free program. We wish to make sure that a company cannot -effectively restrict the users of a free program by obtaining a -restrictive license from a patent holder. Therefore, we insist that -any patent license obtained for a version of the library must be -consistent with the full freedom of use specified in this license. - - Most GNU software, including some libraries, is covered by the -ordinary GNU General Public License. This license, the GNU Lesser -General Public License, applies to certain designated libraries, and -is quite different from the ordinary General Public License. We use -this license for certain libraries in order to permit linking those -libraries into non-free programs. - - When a program is linked with a library, whether statically or using -a shared library, the combination of the two is legally speaking a -combined work, a derivative of the original library. The ordinary -General Public License therefore permits such linking only if the -entire combination fits its criteria of freedom. The Lesser General -Public License permits more lax criteria for linking other code with -the library. - - We call this license the "Lesser" General Public License because it -does Less to protect the user's freedom than the ordinary General -Public License. It also provides other free software developers Less -of an advantage over competing non-free programs. These disadvantages -are the reason we use the ordinary General Public License for many -libraries. However, the Lesser license provides advantages in certain -special circumstances. - - For example, on rare occasions, there may be a special need to -encourage the widest possible use of a certain library, so that it -becomes -a de-facto standard. To achieve this, non-free programs must be -allowed to use the library. A more frequent case is that a free -library does the same job as widely used non-free libraries. In this -case, there is little to gain by limiting the free library to free -software only, so we use the Lesser General Public License. - - In other cases, permission to use a particular library in non-free -programs enables a greater number of people to use a large body of -free software. For example, permission to use the GNU C Library in -non-free programs enables many more people to use the whole GNU -operating system, as well as its variant, the GNU/Linux operating -system. - - Although the Lesser General Public License is Less protective of the -users' freedom, it does ensure that the user of a program that is -linked with the Library has the freedom and the wherewithal to run -that program using a modified version of the Library. - - The precise terms and conditions for copying, distribution and -modification follow. Pay close attention to the difference between a -"work based on the library" and a "work that uses the library". The -former contains code derived from the library, whereas the latter must -be combined with the library in order to run. -^L - GNU LESSER GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License Agreement applies to any software library or other -program which contains a notice placed by the copyright holder or -other authorized party saying it may be distributed under the terms of -this Lesser General Public License (also called "this License"). -Each licensee is addressed as "you". - - A "library" means a collection of software functions and/or data -prepared so as to be conveniently linked with application programs -(which use some of those functions and data) to form executables. - - The "Library", below, refers to any such software library or work -which has been distributed under these terms. A "work based on the -Library" means either the Library or any derivative work under -copyright law: that is to say, a work containing the Library or a -portion of it, either verbatim or with modifications and/or translated -straightforwardly into another language. (Hereinafter, translation is -included without limitation in the term "modification".) - - "Source code" for a work means the preferred form of the work for -making modifications to it. For a library, complete source code means -all the source code for all modules it contains, plus any associated -interface definition files, plus the scripts used to control -compilation -and installation of the library. - - Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running a program using the Library is not restricted, and output from -such a program is covered only if its contents constitute a work based -on the Library (independent of the use of the Library in a tool for -writing it). Whether that is true depends on what the Library does -and what the program that uses the Library does. - - 1. You may copy and distribute verbatim copies of the Library's -complete source code as you receive it, in any medium, provided that -you conspicuously and appropriately publish on each copy an -appropriate copyright notice and disclaimer of warranty; keep intact -all the notices that refer to this License and to the absence of any -warranty; and distribute a copy of this License along with the -Library. - You may charge a fee for the physical act of transferring a copy, -and you may at your option offer warranty protection in exchange for a -fee. - - 2. You may modify your copy or copies of the Library or any portion -of it, thus forming a work based on the Library, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) The modified work must itself be a software library. - - b) You must cause the files modified to carry prominent notices - stating that you changed the files and the date of any change. - - c) You must cause the whole of the work to be licensed at no - charge to all third parties under the terms of this License. - - d) If a facility in the modified Library refers to a function or a - table of data to be supplied by an application program that uses - the facility, other than as an argument passed when the facility - is invoked, then you must make a good faith effort to ensure that, - in the event an application does not supply such function or - table, the facility still operates, and performs whatever part of - its purpose remains meaningful. - - (For example, a function in a library to compute square roots has - a purpose that is entirely well-defined independent of the - application. Therefore, Subsection 2d requires that any - application-supplied function or table used by this function must - be optional: if the application does not supply it, the square - root function must still compute square roots.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Library, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Library, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote -it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Library. - -In addition, mere aggregation of another work not based on the Library -with the Library (or with a work based on the Library) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may opt to apply the terms of the ordinary GNU General Public -License instead of this License to a given copy of the Library. To do -this, you must alter all the notices that refer to this License, so -that they refer to the ordinary GNU General Public License, version 2, -instead of to this License. (If a newer version than version 2 of the -ordinary GNU General Public License has appeared, then you can specify -that version instead if you wish.) Do not make any other change in -these notices. -^L - Once this change is made in a given copy, it is irreversible for -that copy, so the ordinary GNU General Public License applies to all -subsequent copies and derivative works made from that copy. - - This option is useful when you wish to copy part of the code of -the Library into a program that is not a library. - - 4. You may copy and distribute the Library (or a portion or -derivative of it, under Section 2) in object code or executable form -under the terms of Sections 1 and 2 above provided that you accompany -it with the complete corresponding machine-readable source code, which -must be distributed under the terms of Sections 1 and 2 above on a -medium customarily used for software interchange. - - If distribution of object code is made by offering access to copy -from a designated place, then offering equivalent access to copy the -source code from the same place satisfies the requirement to -distribute the source code, even though third parties are not -compelled to copy the source along with the object code. - - 5. A program that contains no derivative of any portion of the -Library, but is designed to work with the Library by being compiled or -linked with it, is called a "work that uses the Library". Such a -work, in isolation, is not a derivative work of the Library, and -therefore falls outside the scope of this License. - - However, linking a "work that uses the Library" with the Library -creates an executable that is a derivative of the Library (because it -contains portions of the Library), rather than a "work that uses the -library". The executable is therefore covered by this License. -Section 6 states terms for distribution of such executables. - - When a "work that uses the Library" uses material from a header file -that is part of the Library, the object code for the work may be a -derivative work of the Library even though the source code is not. -Whether this is true is especially significant if the work can be -linked without the Library, or if the work is itself a library. The -threshold for this to be true is not precisely defined by law. - - If such an object file uses only numerical parameters, data -structure layouts and accessors, and small macros and small inline -functions (ten lines or less in length), then the use of the object -file is unrestricted, regardless of whether it is legally a derivative -work. (Executables containing this object code plus portions of the -Library will still fall under Section 6.) - - Otherwise, if the work is a derivative of the Library, you may -distribute the object code for the work under the terms of Section 6. -Any executables containing that work also fall under Section 6, -whether or not they are linked directly with the Library itself. -^L - 6. As an exception to the Sections above, you may also combine or -link a "work that uses the Library" with the Library to produce a -work containing portions of the Library, and distribute that work -under terms of your choice, provided that the terms permit -modification of the work for the customer's own use and reverse -engineering for debugging such modifications. - - You must give prominent notice with each copy of the work that the -Library is used in it and that the Library and its use are covered by -this License. You must supply a copy of this License. If the work -during execution displays copyright notices, you must include the -copyright notice for the Library among them, as well as a reference -directing the user to the copy of this License. Also, you must do one -of these things: - - a) Accompany the work with the complete corresponding - machine-readable source code for the Library including whatever - changes were used in the work (which must be distributed under - Sections 1 and 2 above); and, if the work is an executable linked - with the Library, with the complete machine-readable "work that - uses the Library", as object code and/or source code, so that the - user can modify the Library and then relink to produce a modified - executable containing the modified Library. (It is understood - that the user who changes the contents of definitions files in the - Library will not necessarily be able to recompile the application - to use the modified definitions.) - - b) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (1) uses at run time a - copy of the library already present on the user's computer system, - rather than copying library functions into the executable, and (2) - will operate properly with a modified version of the library, if - the user installs one, as long as the modified version is - interface-compatible with the version that the work was made with. - - c) Accompany the work with a written offer, valid for at - least three years, to give the same user the materials - specified in Subsection 6a, above, for a charge no more - than the cost of performing this distribution. - - d) If distribution of the work is made by offering access to copy - from a designated place, offer equivalent access to copy the above - specified materials from the same place. - - e) Verify that the user has already received a copy of these - materials or that you have already sent this user a copy. - - For an executable, the required form of the "work that uses the -Library" must include any data and utility programs needed for -reproducing the executable from it. However, as a special exception, -the materials to be distributed need not include anything that is -normally distributed (in either source or binary form) with the major -components (compiler, kernel, and so on) of the operating system on -which the executable runs, unless that component itself accompanies -the executable. - - It may happen that this requirement contradicts the license -restrictions of other proprietary libraries that do not normally -accompany the operating system. Such a contradiction means you cannot -use both them and the Library together in an executable that you -distribute. -^L - 7. You may place library facilities that are a work based on the -Library side-by-side in a single library together with other library -facilities not covered by this License, and distribute such a combined -library, provided that the separate distribution of the work based on -the Library and of the other library facilities is otherwise -permitted, and provided that you do these two things: - - a) Accompany the combined library with a copy of the same work - based on the Library, uncombined with any other library - facilities. This must be distributed under the terms of the - Sections above. - - b) Give prominent notice with the combined library of the fact - that part of it is a work based on the Library, and explaining - where to find the accompanying uncombined form of the same work. - - 8. You may not copy, modify, sublicense, link with, or distribute -the Library except as expressly provided under this License. Any -attempt otherwise to copy, modify, sublicense, link with, or -distribute the Library is void, and will automatically terminate your -rights under this License. However, parties who have received copies, -or rights, from you under this License will not have their licenses -terminated so long as such parties remain in full compliance. - - 9. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Library or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Library (or any work based on the -Library), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Library or works based on it. - - 10. Each time you redistribute the Library (or any work based on the -Library), the recipient automatically receives a license from the -original licensor to copy, distribute, link with or modify the Library -subject to these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties with -this License. -^L - 11. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Library at all. For example, if a patent -license would not permit royalty-free redistribution of the Library by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Library. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply, and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 12. If the distribution and/or use of the Library is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Library under this License -may add an explicit geographical distribution limitation excluding those -countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 13. The Free Software Foundation may publish revised and/or new -versions of the Lesser General Public License from time to time. -Such new versions will be similar in spirit to the present version, -but may differ in detail to address new problems or concerns. - -Each version is given a distinguishing version number. If the Library -specifies a version number of this License which applies to it and -"any later version", you have the option of following the terms and -conditions either of that version or of any later version published by -the Free Software Foundation. If the Library does not specify a -license version number, you may choose any version ever published by -the Free Software Foundation. -^L - 14. If you wish to incorporate parts of the Library into other free -programs whose distribution conditions are incompatible with these, -write to the author to ask for permission. For software which is -copyrighted by the Free Software Foundation, write to the Free -Software Foundation; we sometimes make exceptions for this. Our -decision will be guided by the two goals of preserving the free status -of all derivatives of our free software and of promoting the sharing -and reuse of software generally. - - NO WARRANTY - - 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO -WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. -EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR -OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY -KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE -LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME -THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN -WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY -AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU -FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR -CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE -LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING -RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A -FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF -SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -DAMAGES. - - END OF TERMS AND CONDITIONS -^L - How to Apply These Terms to Your New Libraries - - If you develop a new library, and you want it to be of the greatest -possible use to the public, we recommend making it free software that -everyone can redistribute and change. You can do so by permitting -redistribution under these terms (or, alternatively, under the terms -of the ordinary General Public License). - - To apply these terms, attach the following notices to the library. -It is safest to attach them to the start of each source file to most -effectively convey the exclusion of warranty; and each file should -have at least the "copyright" line and a pointer to where the full -notice is found. - - - - Copyright (C) - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2 of the License, or (at your option) any later version. - - This library 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - -Also add information on how to contact you by electronic and paper -mail. - -You should also get your employer (if you work as a programmer) or -your -school, if any, to sign a "copyright disclaimer" for the library, if -necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the - library `Frob' (a library for tweaking knobs) written by James -Random Hacker. - - , 1 April 1990 - Ty Coon, President of Vice - -That's all there is to it! + This version of the GNU Lesser General Public License incorporates +the terms and conditions of version 3 of the GNU General Public +License, supplemented by the additional permissions listed below. + + 0. Additional Definitions. + As used herein, "this License" refers to version 3 of the GNU Lesser +General Public License, and the "GNU GPL" refers to version 3 of the GNU +General Public License. + + "The Library" refers to a covered work governed by this License, +other than an Application or a Combined Work as defined below. + + An "Application" is any work that makes use of an interface provided +by the Library, but which is not otherwise based on the Library. +Defining a subclass of a class defined by the Library is deemed a mode +of using an interface provided by the Library. + + A "Combined Work" is a work produced by combining or linking an +Application with the Library. The particular version of the Library +with which the Combined Work was made is also called the "Linked +Version". + + The "Minimal Corresponding Source" for a Combined Work means the +Corresponding Source for the Combined Work, excluding any source code +for portions of the Combined Work that, considered in isolation, are +based on the Application, and not on the Linked Version. + + The "Corresponding Application Code" for a Combined Work means the +object code and/or source code for the Application, including any data +and utility programs needed for reproducing the Combined Work from the +Application, but excluding the System Libraries of the Combined Work. + + 1. Exception to Section 3 of the GNU GPL. + + You may convey a covered work under sections 3 and 4 of this License +without being bound by section 3 of the GNU GPL. + + 2. Conveying Modified Versions. + + If you modify a copy of the Library, and, in your modifications, a +facility refers to a function or data to be supplied by an Application +that uses the facility (other than as an argument passed when the +facility is invoked), then you may convey a copy of the modified +version: + + a) under this License, provided that you make a good faith effort to + ensure that, in the event an Application does not supply the + function or data, the facility still operates, and performs + whatever part of its purpose remains meaningful, or + + b) under the GNU GPL, with none of the additional permissions of + this License applicable to that copy. + + 3. Object Code Incorporating Material from Library Header Files. + + The object code form of an Application may incorporate material from +a header file that is part of the Library. You may convey such object +code under terms of your choice, provided that, if the incorporated +material is not limited to numerical parameters, data structure +layouts and accessors, or small macros, inline functions and templates +(ten or fewer lines in length), you do both of the following: + + a) Give prominent notice with each copy of the object code that the + Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the object code with a copy of the GNU GPL and this license + document. + + 4. Combined Works. + + You may convey a Combined Work under terms of your choice that, +taken together, effectively do not restrict modification of the +portions of the Library contained in the Combined Work and reverse +engineering for debugging such modifications, if you also do each of +the following: + + a) Give prominent notice with each copy of the Combined Work that + the Library is used in it and that the Library and its use are + covered by this License. + + b) Accompany the Combined Work with a copy of the GNU GPL and this license + document. + + c) For a Combined Work that displays copyright notices during + execution, include the copyright notice for the Library among + these notices, as well as a reference directing the user to the + copies of the GNU GPL and this license document. + + d) Do one of the following: + + 0) Convey the Minimal Corresponding Source under the terms of this + License, and the Corresponding Application Code in a form + suitable for, and under terms that permit, the user to + recombine or relink the Application with a modified version of + the Linked Version to produce a modified Combined Work, in the + manner specified by section 6 of the GNU GPL for conveying + Corresponding Source. + + 1) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (a) uses at run time + a copy of the Library already present on the user's computer + system, and (b) will operate properly with a modified version + of the Library that is interface-compatible with the Linked + Version. + + e) Provide Installation Information, but only if you would otherwise + be required to provide such information under section 6 of the + GNU GPL, and only to the extent that such information is + necessary to install and execute a modified version of the + Combined Work produced by recombining or relinking the + Application with a modified version of the Linked Version. (If + you use option 4d0, the Installation Information must accompany + the Minimal Corresponding Source and Corresponding Application + Code. If you use option 4d1, you must provide the Installation + Information in the manner specified by section 6 of the GNU GPL + for conveying Corresponding Source.) + + 5. Combined Libraries. + + You may place library facilities that are a work based on the +Library side by side in a single library together with other library +facilities that are not Applications and are not covered by this +License, and convey such a combined library under terms of your +choice, if you do both of the following: + + a) Accompany the combined library with a copy of the same work based + on the Library, uncombined with any other library facilities, + conveyed under the terms of this License. + + b) Give prominent notice with the combined library that part of it + is a work based on the Library, and explaining where to find the + accompanying uncombined form of the same work. + + 6. Revised Versions of the GNU Lesser General Public License. + + The Free Software Foundation may publish revised and/or new versions +of the GNU Lesser General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + + Each version is given a distinguishing version number. If the +Library as you received it specifies that a certain numbered version +of the GNU Lesser General Public License "or any later version" +applies to it, you have the option of following the terms and +conditions either of that published version or of any later version +published by the Free Software Foundation. If the Library as you +received it does not specify a version number of the GNU Lesser +General Public License, you may choose any version of the GNU Lesser +General Public License ever published by the Free Software Foundation. + + If the Library as you received it specifies that a proxy can decide +whether future versions of the GNU Lesser General Public License shall +apply, that proxy's public statement of acceptance of any version is +permanent authorization for you to choose that version for the +Library. diff --git a/ChangeLog.pre-2-3-1 b/ChangeLog.pre-2-3-1 deleted file mode 100644 index 5cdd5f48..00000000 --- a/ChangeLog.pre-2-3-1 +++ /dev/null @@ -1,2759 +0,0 @@ -2.3.1: - -2012-10-18 Murray Cumming - - Update the Doxyfile.in syntax. - - * docs/reference/Doxyfile.in: By running doxygen -u - on it. - -2012-10-17 Kjell Ahlstedt - - Add some missing newin{}. - - * docs/reference/Doxyfile.in: Add ALIASES newin. - * sigc++/functors/macros/functor_trait.h.m4: Add newin{2,2,11} to - SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE. - * sigc++/signal_base.h: Add newin{2,4} to signal_impl::blocked(), block() and - signal_base::blocked(), block(), unblock(). Bug #153780. - -2012-10-12 Kjell Ahlstedt - - signal_base: Add blocked(), block(), unblock(). - - * sigc++/signal_base.[h|cc]: Add signal_impl::blocked(), block() and - signal_base::blocked(), block(), unblock(). Bug #153780. - -2.2.11: - -2012-09-20 Andris Pavenis - - Fix comma operator in lambda expressions. - - * sigc++/adaptors/lambda/macros/operator.h.m4: Add lambda_action<> - specialization for comma operator (operator,()). - * tests/test_cpp11_lambda.cc: - * tests/test_lambda.cc: Add a test case for the comma operator. Bug #342911. - -2012-09-19 Kjell Ahlstedt - - Add SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE. - - * sigc++/adaptors/lambda/macros/base.h.m4: - * sigc++/adaptors/lambda/macros/group.h.m4: - * sigc++/functors/macros/functor_trait.h.m4: - * tests/test_cpp11_lambda.cc: Replace the preprocessor macro - SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH(C_keyword) with - SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE. Bug #672555. - -2012-09-10 Kjell Ahlstedt - - Use std::size_t and std::ptrdiff_t. - - * sigc++/macros/signal.h.m4: Use std::size_t and std::ptrdiff_t instead - of ::size_t and ::ptrdiff_t. Only the std versions are required to be - declared in . - * sigc++/signal_base.h: Use std::size_t instead of ::size_t. (I did not change - MSVC++-only code in this file and other files.) - -2012-09-07 Kjell Ahlstedt - - Fix 'make check' with gcc 4.7. - - * sigc++/adaptors/lambda/macros/base.h.m4: Define sigc::unwrap_lambda_value() - before it's used in sigc::lambda::operator[]() and operator=(). - * sigc++/adaptors/lambda/macros/group.h.m4: Fix the C++11 examples in the - documentation as in test_cpp11_lambda.cc. - * tests/test_cpp11_lambda.cc: Only variables with automatic storage duration - shall be captured in C++11 lambda expressions. - -2012-08-28 Kjell Ahlstedt - - Update .gitignore and tests/.gitignore - - * .gitignore: Add *~ (gedit's backup files). - * tests/.gitignore: Add missing executable test files. - -2012-08-28 Kjell Ahlstedt - - Add SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH for C++11 lambda expressions. - - * sigc++/functors/macros/functor_trait.h.m4: Add the preprocessor macro - SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH(C_keyword), which makes it possible to - assign C++11 lambda expressions with any return type to slots. - Thanks to Chow Loong Jin, who posted similar code on libsigc-list. - * sigc++/adaptors/lambda/macros/base.h.m4: - * sigc++/adaptors/lambda/macros/group.h.m4: Add information on C++11 lambda - expressions to the documentation of lambda expressions and sigc::group(). - * tests/Makefile.am: Add test_cpp11_lambda.cc. - * tests/test_cpp11_lambda.cc: New test case, showing that most uses of - libsigc++'s lambda expressions can be replaced by standard C++11 lambda - expressions. Bug #672555. - -2012-03-19 Kjell Ahlstedt - - Enable test_lambda in 'make check'. - - * tests/Makefile.am: Enable test_lambda in 'make check'. - * tests/test_lambda.cc: Comment out the tests with sigc::ref() in lambda - functions' parameter lists. See Bug #669128. - -2.2.10: - -2011-07-21 Thomas Rydzynski - - Mention visit_each() in the documentation of sigc::adapts. - - * sigc++/adaptors/macros/adaptor_trait.h.m4: Mention that a user-supplied - adaptor must be accompanied by a specialization of template function - visit_each(). Correct some minor errors in the example of a user-supplied - adaptor. Bug #486373. - -2011-07-19 Kjell Ahlstedt - - Add a test case for the previous commit. - - * tests/Makefile.am: - * tests/test_bind_refptr.cc: A version of this test is also in glibmm. - Note that this includes a copy/paste of RefPtr. - See Bug #564005#14 (Alexander Shaduri) - -2011-07-14 Kjell Ahlstedt - - slot_rep: Avoid access to deleted object in notify(). - - * sigc++/functors/slot_base.cc: slot_rep::notify() calls disconnect() before - destroy(). If disconnect() has deleted the slot_rep object, destroy() is not - called. Bug #564005. - -2.2.9: - -2011-02-22 Kjell Ahlstedt - - trackable: Avoid calling the same callback function twice - - * sigc++/trackable.cc: Invalidate a callback function entry in - trackable_callback_list::remove_callback() when the list is being cleared. - Bug 589202. - -2011-02-04 Kalev Lember - - Fix the build with GCC 4.6 - - * sigc++/signal_base.h: Include for size_t. - -2010-10-12 David King - - Documentation changes - - * *.h.m4: Minor changes to documentation to fix up code example - formatting, by removing the additional two spaces of indentation. - Additionally, fix some spelling and grammar mistakes and typos. - -2010-09-27 Armin Burgmeier - - * MSVC_Net2005/libsigc++2.sln: - * MSVC_Net2005/libsigc++2.vcproj: - * MSVC_Net2005/tests/test_accumulated/test_accumulated.vcproj: - * MSVC_Net2005/tests/test_bind/test_bind.vcproj: - * MSVC_Net2005/tests/test_bind_return/test_bind_return.vcproj: - * MSVC_Net2005/tests/test_compose/test_compose.vcproj: - * MSVC_Net2005/tests/test_deduce_result_type/test_deduce_result_type.vcproj: - * MSVC_Net2005/tests/test_disconnect/test_disconnect.vcproj: - * MSVC_Net2005/tests/test_disconnect_during_emit/test_disconnect_during_emit.vcproj: - * MSVC_Net2005/tests/test_exception_catch/test_exception_catch.vcproj: - * MSVC_Net2005/tests/test_functor_trait/test_functor_trait.vcproj: - * MSVC_Net2005/tests/test_hide/test_hide.vcproj: - * MSVC_Net2005/tests/test_mem_fun/test_mem_fun.vcproj: - * MSVC_Net2005/tests/test_ptr_fun/test_ptr_fun.vcproj: - * MSVC_Net2005/tests/test_retype/test_retype.vcproj: - * MSVC_Net2005/tests/test_retype_return/test_retype_return.vcproj: - * MSVC_Net2005/tests/test_signal/test_signal.vcproj: - * MSVC_Net2005/tests/test_size/test_size.vcproj: - * MSVC_Net2005/tests/test_slot/test_slot.vcproj: - * MSVC_Net2005/tests/test_trackable/test_trackable.vcproj: - * MSVC_Net2008/libsigc++2.sln: - * MSVC_Net2008/libsigc++2.vcproj: - * MSVC_Net2008/tests/test_accumulated/test_accumulated.vcproj: - * MSVC_Net2008/tests/test_bind/test_bind.vcproj: - * MSVC_Net2008/tests/test_bind_return/test_bind_return.vcproj: - * MSVC_Net2008/tests/test_compose/test_compose.vcproj: - * MSVC_Net2008/tests/test_deduce_result_type/test_deduce_result_type.vcproj: - * MSVC_Net2008/tests/test_disconnect/test_disconnect.vcproj: - * MSVC_Net2008/tests/test_disconnect_during_emit/test_disconnect_during_emit.vcproj: - * MSVC_Net2008/tests/test_exception_catch/test_exception_catch.vcproj: - * MSVC_Net2008/tests/test_functor_trait/test_functor_trait.vcproj: - * MSVC_Net2008/tests/test_hide/test_hide.vcproj: - * MSVC_Net2008/tests/test_mem_fun/test_mem_fun.vcproj: - * MSVC_Net2008/tests/test_ptr_fun/test_ptr_fun.vcproj: - * MSVC_Net2008/tests/test_retype/test_retype.vcproj: - * MSVC_Net2008/tests/test_retype_return/test_retype_return.vcproj: - * MSVC_Net2008/tests/test_signal/test_signal.vcproj: - * MSVC_Net2008/tests/test_size/test_size.vcproj: - * MSVC_Net2008/tests/test_slot/test_slot.vcproj: - * MSVC_Net2008/tests/test_trackable/test_trackable.vcproj: - * MSVC_Net2010/libsigc++2.vcxproj: - * MSVC_Net2010/tests/test_accumulated/test_accumulated.vcxproj: - * MSVC_Net2010/tests/test_bind/test_bind.vcxproj: - * MSVC_Net2010/tests/test_bind_return/test_bind_return.vcxproj: - * MSVC_Net2010/tests/test_compose/test_compose.vcxproj: - * MSVC_Net2010/tests/test_deduce_result_type/test_deduce_result_type.vcxproj: - * MSVC_Net2010/tests/test_disconnect/test_disconnect.vcxproj: - * MSVC_Net2010/tests/test_disconnect_during_emit/test_disconnect_during_emit.vcxproj: - * MSVC_Net2010/tests/test_exception_catch/test_exception_catch.vcxproj: - * MSVC_Net2010/tests/test_functor_trait/test_functor_trait.vcxproj: - * MSVC_Net2010/tests/test_hide/test_hide.vcxproj: - * MSVC_Net2010/tests/test_mem_fun/test_mem_fun.vcxproj: - * MSVC_Net2010/tests/test_ptr_fun/test_ptr_fun.vcxproj: - * MSVC_Net2010/tests/test_retype/test_retype.vcxproj: - * MSVC_Net2010/tests/test_retype_return/test_retype_return.vcxproj: - * MSVC_Net2010/tests/test_signal/test_signal.vcxproj: - * MSVC_Net2010/tests/test_size/test_size.vcxproj: - * MSVC_Net2010/tests/test_slot/test_slot.vcxproj: - * MSVC_Net2010/tests/test_trackable/test_trackable.vcxproj: Add 64 - bit support to MSVC project files. - -2010-09-27 Armin Burgmeier - - * MSVC_Net2005/libsigc++2.sln: - * MSVC_Net2005/tests/test_accumulated/test_accumulated.vcproj: - * MSVC_Net2008/libsigc++2.sln: - * MSVC_Net2008/tests/test_accumulated/test_accumulated.vcproj: Add - test_accumulated to the MSVC projects. - -2010-09-19 Armin Burgmeier - - * MSVC_Net2010/filelist.am: - * MSVC_Net2010/libsigc++2.sln: - * MSVC_Net2010/libsigc++2.vcxproj: - * MSVC_Net2010/libsigc++2.vcxproj.filters: - * MSVC_Net2010/sigc.rc.in: - * MSVC_Net2010/tests/test_accumulated/test_accumulated.vcxproj: - * MSVC_Net2010/tests/test_accumulated/test_accumulated.vcxproj.filters: - * MSVC_Net2010/tests/test_bind/test_bind.vcxproj: - * MSVC_Net2010/tests/test_bind/test_bind.vcxproj.filters: - * MSVC_Net2010/tests/test_bind_return/test_bind_return.vcxproj: - * MSVC_Net2010/tests/test_bind_return/test_bind_return.vcxproj.filters: - * MSVC_Net2010/tests/test_compose/test_compose.vcxproj: - * MSVC_Net2010/tests/test_compose/test_compose.vcxproj.filters: - * MSVC_Net2010/tests/test_deduce_result_type/test_deduce_result_type.vcxproj: - * MSVC_Net2010/tests/test_deduce_result_type/test_deduce_result_type.vcxproj.filters: - * MSVC_Net2010/tests/test_disconnect/test_disconnect.vcxproj: - * MSVC_Net2010/tests/test_disconnect/test_disconnect.vcxproj.filters: - * MSVC_Net2010/tests/test_disconnect_during_emit/test_disconnect_during_emit.vcxproj: - * MSVC_Net2010/tests/test_disconnect_during_emit/test_disconnect_during_emit.vcxproj.filters: - * MSVC_Net2010/tests/test_exception_catch/test_exception_catch.vcxproj: - * MSVC_Net2010/tests/test_exception_catch/test_exception_catch.vcxproj.filters: - * MSVC_Net2010/tests/test_functor_trait/test_functor_trait.vcxproj: - * MSVC_Net2010/tests/test_functor_trait/test_functor_trait.vcxproj.filters: - * MSVC_Net2010/tests/test_hide/test_hide.vcxproj: - * MSVC_Net2010/tests/test_hide/test_hide.vcxproj.filters: - * MSVC_Net2010/tests/test_mem_fun/test_mem_fun.vcxproj: - * MSVC_Net2010/tests/test_mem_fun/test_mem_fun.vcxproj.filters: - * MSVC_Net2010/tests/test_ptr_fun/test_ptr_fun.vcxproj: - * MSVC_Net2010/tests/test_ptr_fun/test_ptr_fun.vcxproj.filters: - * MSVC_Net2010/tests/test_retype/test_retype.vcxproj: - * MSVC_Net2010/tests/test_retype/test_retype.vcxproj.filters: - * MSVC_Net2010/tests/test_retype_return/test_retype_return.vcxproj: - * MSVC_Net2010/tests/test_retype_return/test_retype_return.vcxproj.filters: - * MSVC_Net2010/tests/test_signal/test_signal.vcxproj: - * MSVC_Net2010/tests/test_signal/test_signal.vcxproj.filters: - * MSVC_Net2010/tests/test_size/test_size.vcxproj: - * MSVC_Net2010/tests/test_size/test_size.vcxproj.filters: - * MSVC_Net2010/tests/test_slot/test_slot.vcxproj: - * MSVC_Net2010/tests/test_slot/test_slot.vcxproj.filters: - * MSVC_Net2010/tests/test_trackable/test_trackable.vcxproj: - * MSVC_Net2010/tests/test_trackable/test_trackable.vcxproj.filters: - - * Makefile.am: - * configure.ac: Added project files for Visual Studio 2010. - -2010-06-05 David King - - Small website updates - - * docs/index.html: Remove broken namespace links. - * docs/website/doc.shtml: Link to library.gnome.org tutorial and API - reference. - -2.2.8: - -2010-06-04 Murray Cumming - - Manual: Add an id="index" attribute in case that helps library.gnome.org. - - * docs/manual/libsigc_manual.xml: Add it to the tag. - -2.2.7: - -2010-05-04 Murray Cumming - - Documentation improvements. - - * docs/manual/libsigc_manual.xml: Remove Marshallers section because - it is apparently outdated and there is no example code to test it. - This fixes bug #417924 (Michael Ekstrand) - * sigc++/sigc++.h: Main page text: Rearranged slightly. - -2010-04-27 David King - - Improvements to main page documentation - - * sigc++/sigc++.h: Minor improvements. - -2010-04-23 David King - - Add main page to Doxygen documentation - - * docs/Makefile.am: Parse sigc++/sigc++.h for documentation. - * sigc++/sigc++.h: Add main page to Doxygen documentation. - -2010-04-23 David King - - Fix the functors Doxygen group in the m4 files - - * sigc++/functors/macros/functor_trait.h.m4: - * sigc++/functors/macros/mem_fun.h.m4: - * sigc++/functors/macros/ptr_fun.h.m4: Rename functors to - sigcfunctors. - -2.2.6: - -2010-04-16 Murray Cumming - - Docs: Fix the functors group and the link from the overview. - - * docs/website/doc.shtml: Revert this to point to the overview page at - docs/indeex.html, which I have manually uploaded to the website, until - we add this overview to the doxygen-generated documentation itself. - * sigc++/functors/slot_base.h: - * sigc++/visit_each.h: Rename the functors doxygen group to sigcfunctors, - because doxygen seems to confuse it with the one in libstdc++. - * docs/index.html: Update the links. - -2010-04-16 Murray Cumming - - Website: Fix the Makefile so upload works with sourceforge again. - -2010-04-06 Murray Cumming - - Website: Update the reference API link. - - * docs/website/doc.shtml: Update the reference API link to use - library.gnome.org. We should make sure that the tutorial docbook is there - too. - * docs/website/devel.shtml: Remove CVS-specific instructions, quickly - mentioning the git module instead. - However, the Makefile must be updated to cope with sourceforge's changes. - I was not able to upload this yet. - -2.2.5: - -2010-01-05 Daniel Elstner - - Use non-blurry font for dot graph labels - - * docs/reference/Doxyfile.in (SHOW_INCLUDE_FILES): Enable. - (SHOW_USED_FILES): Disable. - (DOT_FONTNAME): Change from FreeSans to Sans, as the hinting for the - former appears to be rather bad. - (TEMPLATE_RELATIONS): Disable to reduce noise. - -2009-12-29 Krzysztof Kosiński - - Accumulators: Allow return types that are different to the signal's. - - * sigc++/macros/signal.h.m4: signal_emit*: Correct the slot_iterator_buf_type - and slot_reverse_iterator_buf_type typedefs to allow accumulators with - return types that are different to the signal's return type. - * tests/Makefile.am: Reenable test_accumulated, so we can test the fix. - It should be manually disabled if building on AIX (if the AIX problem cannot - be fixed properly). - * tests/test_accumulated.cc: Add an accumulator with a return type that is - different to the signal's return type. In this case it's a vector listing - all results. - Bug #586436. - -2009-12-27 Daniel Elstner - - Disable collaboration graphs in documentation - - * docs/reference/Doxyfile.in (CLASS_DIAGRAMS): Enable. Contrary to - what the Doxygen documentation says, no dot class inheritance graphs - will be generated if both CLASS_DIAGRAMS and COLLABORATION_GRAPH are - set to NO. - (COLLABORATION_GRAPH), (GROUP_GRAPHS): Turn off additional graphs to - reduce the noise. - -2009-10-26 Armin Burgmeier - - * sigc++config.h: Move the first five definitions to the !SIGC_MSC - ifdef block, so MSVC does not see them and only uses the definitions - from the SIGC_MSC block. This fixes the build with MSVC. - -2009-09-19 Daniel Elstner - - Support Automake silent rules - - * configure.ac: Call the AM_SILENT_RULES macro if it is defined. - * docs/doc-manual.am, sigc++/Makefile.am: Prefix the commands of - custom rules with $(AM_V_GEN) or $(AM_V_at) in order to support - the silent rules feature of Automake. - -2009-09-17 Michael Hasselmann - - Documentation cleanup: sigc::hide() always only hides one signal argument - - * sigc++/adaptors/macros/hide.h.m4: The documentation stated that sigc::hide() - could discard multiple signal arguments when in fact the whole API only allows - control over one (dummy) signal argument at a time. The "multiple argument - hiding" example lives in it own section now to make it clearer you have to nest - sigc::hide() for that. - -2009-09-13 Daniel Elstner - - Enable verbose output of autoreconf - - * autogen.sh: Pass --verbose option to autoreconf. - -2.2.4.2: - -2009-09-02 Daniel Elstner - - Bump version to 2.2.4.2 and update NEWS - - * configure.ac (AC_INIT): Increment version number to 2.2.4.2. - (MM_PREREQ): Require mm-common 0.7.2. - * NEWS: Write news entry for libsigc++ 2.2.4.2. - -2009-09-02 Daniel Elstner - - Document namespace sigc briefly - - * sigc++/signal_base.h (sigc): Prepend documentation comment to - provide a brief description of namespace sigc, so that Doxygen - will recognize the namespace as documented. - -2009-08-31 Daniel Elstner - - Update Doxygen configuration for Doxygen 1.6.1 - - * docs/reference/Doxyfile.in: Update configuration template using - Doxygen 1.6.1. - (SORT_MEMBERS_CTORS_1ST): Enable. - -2009-08-31 Daniel Elstner - - Protect space after comma in M4 output - - * sigc++/macros/template.macros.m4 (_LOOP_SEP): Triple-quote the - list separator in this hairy construct, since the macro definition - itself is not quoted at all and the space after the comma got lost - in the output. This, in turn, produced overlong lines in the HTML - reference documentation. - -2.2.4.1: - -2009-08-28 Daniel Elstner - - Update news entry for libsigc++ 2.2.4.1 release - - * NEWS: Update top entry for release 2.2.4.1 of libsigc++. - (2.2.4): Correct spelling of Frédéric Péters' name. - -2009-08-27 Daniel Elstner - - Use shared mm-common Doxygen style sheet - - * configure.ac (MM_PREREQ): Require mm-common 0.7. - * docs/Makefile.am (dist_noinst_DATA): List doxygen.css. - * docs/reference/Doxyfile.in (HTML_STYLESHEET): Assign path - to the shared doxygen.css provided by mm-common. - -2009-08-27 Daniel Elstner - - Remove header and footer HTML fragments - - * docs/reference/libsigc_{header,footer}.html_fragment: Delete - files. These custom fragments were an unnecessary maintenance - hassle. Also, the files were out of date with respect to the - encoding and CSS classes used by Doxygen. - * docs/reference/Doxyfile.in (HTML_HEADER), (HTML_FOOTER): Set - to the empty string. - (PROJECT_NAME): Substitute @PACKAGE_NAME@. - (PROJECT_NUMBER): Substitute @PACKAGE_VERSION@. It does look - nicer in the generated HTML pages, and is probably also less - confusing. - (SORT_GROUP_NAMES): Enable for predictability. - -2009-08-26 Daniel Elstner - - Bump version to 2.2.4.1 and update NEWS - - * configure.ac (AC_INIT): Increment version number to 2.2.4.1. - * NEWS: Write news entry for libsigc++ 2.2.4.1. - -2009-08-26 Daniel Elstner - - Reenable hierarchy graphs for each class - - * docs/reference/Doxyfile.in (COLLABORATION_GRAPH): Set option - to YES to enable the per-class inheritance graphs. - -2009-08-25 Daniel Elstner - - Have Automake check NEWS and use bzip2 - - * configure.ac (AM_INIT_AUTOMAKE): Add options check-news and - dist-bzip2. - -2009-08-25 Daniel Elstner - - Update NEWS for libsigc++ 2.2.4 release - -2009-08-25 Daniel Elstner - - Bump version to 2.2.4 and require mm-common 0.6.1 - - * configure.ac (AC_INIT): Increase version number to 2.2.4. - (MM_PREREQ): Require mm-common 0.6.1 for the updated default - location of the reference documentation. - -2009-08-25 Daniel Elstner - - Change documentation host to library.gnome.org - - * README, docs/manual/libsigc_manual.xml: Adjust links to the - reference documentation in the text. - * docs/Makefile.am (pubdocbase), (htmlrefpub): Remove override - and use the updated mm-common default values. - * sigc++{,-uninstalled}.pc.in (htmlrefpub): Adjust link. - -2009-08-24 Daniel Elstner - - Add id="content" element to documentation index - - * docs/reference/libsigc_header.html_fragment: Start
element - with attribute id="content" to match the other C++ binding modules. - * docs/reference/libsigc_footer.html_fragment: Close
element. - -2009-08-20 Daniel Elstner - - Use new version component substitutions - - * MSVC_Net200[58]/sigc.rc.in: Replace the no longer defined - @FP_*_VERSION@ substitutions by the new @SIGCXX_*_VERSION@ - substitutions for the version number components. These are - defined by MM_INIT_MODULE() from mm-common. - -2009-08-20 Daniel Elstner - - Substitute API version in filenames dynamically - - * sigc++.pc.in: Rename file from sigc++-2.0.pc.in. - * sigc++-uninstalled.pc.in: Rename file from - sigc++-2.0-uninstalled.pc.in. - * MSVC_Net200[58]/sigc.rc.in: Rename files from sigc-2.0.rc.in - and use @SIGCXX_API_VERSION@ substitution for the API version. - Also replace @VERSION@ with @PACKAGE_VERSION@. - * MSVC_Net200[58]/libsigc++2.{sln,vcproj}: Remove version from - the project name and filenames. - * MSVC_Net200[58]/filelist.am: Remove version from filenames. - * configure.ac (AC_CONFIG_FILES): Insert ${SIGCXX_MODULE_NAME} - into output filenames and remove the version from the input - filenames. - * Makefile.am: Use $(SIGCXX_MODULE_NAME) in pkg-config file - names instead of hard-coding the API version. - * sigc++/Makefile.am (lib_LTLIBRARIES): Instead of hard-coding - the libtool archive name, substitute @SIGCXX_API_VERSION@ into - it, as well as into the derived variable names. - -2009-08-17 Daniel Elstner - - Set libtool version information - - * sigc++/Makefile.am (libsigc_2_0_la_LDFLAGS): Add libtool option - -version-info 0:0:0 to specify the version information explicitly. - -2009-08-16 Daniel Elstner - - Remove unused parameter names for correctness - - * tests/test_copy_invalid_slot.cc, tests/test_custom.cc, - tests/test_deduce_result_type.cc, tests/test_functor_trait.cc, - tests/test_limit_reference.cc: Remove the names of unused function - parameters from the prototype, in order to get libsigc++ to build - with fatal compiler warnings. - -2009-08-16 Daniel Elstner - - Rename scripts/ to build/ for consistency - - * build/: Rename directory from scripts/ for consistency with most - of the other modules that switched to the new build infrastructure. - * Makefile.am (ACLOCAL_AMFLAGS): Adjust M4 include directory. - * README: Adjust a reference to scripts/ in the text. - * configure.ac (AC_CONFIG_AUX_DIR): Copy auxiliary files to build/. - (AC_CONFIG_MACRO_DIR): Place Autoconf M4 files into build/. - * docs/Makefile.am: Include $(top_srcdir)/build/doc-reference.am. - -2009-08-16 Daniel Elstner - - Update for latest mm-common 0.4 - - * configure.ac (MM_PREREQ): Require mm-common 0.4. - (MM_INIT_MODULE): Omit now optional version number argument. - (MM_CONFIG_DOCTOOL_DIR): Copy the documentation utilities into docs/ - instead of scripts/. - * Makefile.am (dist_noinst_DATA): Remove documentation utilities. - * sigc++-2.0.pc.in (htmlrefpub): Append trailing slash. - * sigc++-2.0-uninstalled.pc.in (htmlrefpub): ditto, - * docs/Makefile.am (htmlrefpub): ditto. - (doc_input): Perform a VPATH search for each input file, to correctly - handle the case of rebuilding the documentation of a tarball release - which includes the generated sources. - (dist_noinst_DATA): List documentation utilities. - -2009-08-11 Daniel Elstner - - Do not recurse into MSVC subdirectories - - * MSVC_Net200[58]/filelist.am: New Automake include files, defining - the lists of files to ship from the MSVC project directories. - * MSVC_Net200[58]/Makefile.am: Delete recursive Makefile.am files. - * Makefile.am: Include MSVC_Net200[58]/filelist.am. - (dist_noinst_DATA): Distribute MSVC project files. - (SUBDIRS): Do not recurse into the MSVC_Net200[58] subdirectories. - * configure.ac (AC_CONFIG_FILES): Remove the output files - MSVC_Net200[58]/Makefile.am from the list. - (AC_CONFIG_COMMANDS): Copy sigc++config.h into the MSVC project - directories at the end of config.status. - -2009-08-11 Daniel Elstner - - Remove now superfluous doctool overrides - - * docs/Makefile.am: Remove overrides for the documentation - utilities, since MM_CONFIG_DOCTOOL_DIR() already takes care - of setting MMDOCTOOLDIR to the local directory. - * sigc++-2.0.pc.in (datadir): Substitute value, just in case. - -2009-08-10 Daniel Elstner - - Have mm-common-prepare install the doc utils - - * configure.ac: Call MM_CONFIG_DOCTOOL_DIR([scripts]) to set - up the destination directory for mm-common-prepare to copy - the documentation utilities to. - * scripts/doc-install.pl: Delete file. - * scripts/doc-postprocess.pl: ditto, - * scripts/tagfile-to-devhelp2.xsl: ditto. - -2009-08-09 Daniel Elstner - - Refresh doc-install and doc-postprocess copies - - * scripts/doc-install.pl, scripts/doc-postprocess.pl: Copy - latest versions from the mm-common module. - * docs/Makefile.am (doc_install), (doc_postprocess): Include - $(PERL) interpreter command in front of the script name. - -2009-08-08 Daniel Elstner - - Disable extraction of undocumented identifiers - - * docs/reference/Doxyfile.in (EXTRACT_ALL): Change setting to - NO, and adapt a number of related options accordingly. The - result is a net loss of about 300 generated .html files. The - roughly 450 files which remain now are still an insanely high - number, though. - (PREDEFINED): Predefine the Autoconf configuration defines to - nudge Doxygen towards documenting the canonical code paths. - -2009-08-07 Daniel Elstner - - Use #error explicitly instead of broken code - - * sigc++config.h.in: Do use the #error preprocessor directive, - instead of an errornous piece of code. This code does not need - the same level of obfuscation as an Autoconf feature test. - -2009-08-07 Daniel Elstner - - Change bug report URL to point to Bugzilla - - * configure.ac (AC_INIT): Change the bug-report argument to the - URL for filing a new libsigc++ bug on bugzilla.gnome.org. Also - name the website URL as fifth argument. It will simply be ignored - if the installed Autoconf does not support this new feature. - -2009-08-07 Daniel Elstner - - Do not enable -pedantic mode by default - - * configure.ac (MM_ARG_ENABLE_WARNINGS): Remove -pedantic from the - list of compiler flags to use at warning level "min" (the default). - -2009-08-07 Daniel Elstner - - Correct M4 forbidden tokens pattern - - * configure.ac (m4_pattern_forbid): Take into account that the - pattern is applied to tokens, not lines. Also catch unexpanded - calls to underscore-prefixed private macros. - -2009-08-06 Daniel Elstner - - Transition to new mm-common build infrastructure - - * autogen.sh: Replace with a minimal script that simply executes - mm-common-prepare, autoreconf and configure. - * configure.ac: Get rid of an enormous amount of old cruft. Use - macros from the new mm-common module to set up Doxygen for building - the documentation. Add option to enable more compiler warnings. - * sigc++-2.0-uninstalled.pc.in: New pkg-config data file to allow - linking to an uninstalled libsigc++. - * sigc++-2.0.pc.in: Modernize. Provide the location of the - installed reference documentation and the Doxygen tag file. - * sigc++config.h.in: Modernize and update for new build - infrastructure. - * Makefile.am, */Makefile.am: Modernize and adapt to the new C++ - binding build infrastructure in the mm-common module. - * sigc++/filelist.am: New Automake include file. Defines lists - of C++ and M4 source files. - * docs/Makefile.am: Rewrite using doc-reference.am from the - mm-common module. - * docs/doc-manual.am: New Automake include file for building the - libsigc++ Docbook manual. - * docs/images/Makefile.am: Remove file. - * docs/manual/Makefile.am: ditto, - * docs/reference/Makefile.am: ditto. - * docs/Makefile_web.am_fragment: Remove for now, to be taken care - of later. - * docs/reference/Doxyfile.in: Modernize and adapt to new build - infrastructure. - * docs/reference/beautify_docs.pl: Remove and use the more recent - scripts/doc-postprocess.pl instead. - * libsigc++-2.0.spec.in: Remove, to be resurrected only if someone - complains. - * scripts/Makefile.am: Remove file. Distribute the files from the - toplevel Makefile.am instead. - * scripts/cxx_std.m4: Add missing third argument to AC_DEFINE(). - * scripts/doc-install.pl: New file, copied from mm-common. - * scripts/doc-postprocess.pl: ditto, - * scripts/tagfile-to-devhelp2.xsl: ditto. - -2008-11-13 Murray Cumming - - * docs/website/stable.shtml: Correct the download link so it shows all - versions, not just 2.0. - -2.2.3: - -2008-10-08 Armin Burgmeier - - * MSVN_Net2005/libsigc++2.vcproj: Changed output name to match the new - naming convention. - - * MSVC_Net2008/: Added MSVC 2008 project files. These are basically - the same as for MSVC 2005, but converted to MSVC 2008 projects. - - * configure.ac: - * Makefile.am: Added the new files to the build. - -2008-08-08 Armin Burgmeier - - * MSVC_Net2005/libsigc++2.sln: Enable the disconnect_during_emit test - by default. - - * MSVC_Net2005/libsigc++2.vcproj: Renamed the generated debug database - file to sigc-2.0d.pdb (the default), to stay consistent with the *mm - wrapper libraries. - -2008-08-08 Armin Burgmeier - - * MSVC_Net2005/: Moved from MSVC_Net2003. - - * MSVC_Net2005/libsigc++2.sln: - * MSVC_Net2005/libsigc++2.vcproj: - * MSVC_Net2005/tests/*/*.vcproj: Converted the Visual Studio 2003 - project files to 2005 ones. - - * MSVC_Net2005/Makefile.am: - * Makefile.am: - * configure.ac: Adapted build files accordingly. - -2008-04-06 Cedric Gustin - - * MSVC_Net2003/sigc-2.0.rc.in: Removed ATL/MFC header files - dependency as afxres.h is not part of the Microsoft Platform - SDK provided with Visual C++ Express 2008. - Bug #503933. - -2.2.2: - -2008-03-10 Deng Xiyue - - * sigc++/macros/signal.h.m4: - * tests/test_accum_iter.cc: Add ifdefs around uses of - reverse_iterator to really fix the build with recent - versions of Sun CC. - Bug #302098. - -2.2.0: - -2008-01-01 Ryan Hill - - * tests/test_copy_invalid_slot.cc: Include the cstdlib - and cstring headers to fix the build with the gcc 4.3 - pre-release. Bug #454882. - -2007-08-31 Murray Cumming - - * tests/test_copy_invalid_slot.cc: Added some includes to - fix the build in some environments, such as when using Sun CC. - Thanks to Vladimir Marek in bug #469872. - -2.1.1: - -2007-08-14 Murray Cumming - - * sigc++/Makefile.am: - * sigc++/compatibility.h: Removed this header. - * sigc++/bind.h: - * sigc++/bind_return.h: - * sigc++/connection.h: - * sigc++/macros/class_slot.h.m4: - * sigc++/macros/hide.h.m4: - * sigc++/macros/method_slot.h.m4: - * sigc++/macros/object_slot.h.m4: - * sigc++/macros/retype.h.m4: - * sigc++/macros/signal.h.m4: - * sigc++/macros/slot.h.m4: - * sigc++/object.h: - * sigc++/retype_return.h: Removed deprecated - compatibility API, to probably fix the build with - some compilers, such as some versions of the Sun Forte C++ - CC compiler. Some of these headers are now mostly empty and - should be removed later. - This API has been deprecated April 2004, and - is not widely used, so it seems safe to do this now. - - * tests/Makefile.am: - * tests/test_compatibility.cc: Removed this test. - -2007-07-28 Michael Elkstrand - - * sigc++/macros/signal.h.m4: slot_iterator_buf, - slot_reverse_iterator_buf: Added typedefs for - value_type, reference, and pointer, so that these - iterators are more like standard C++ iterators, so they can - be used with standard C++ algorithms. - * tests/Makefile.am: - * tests/test_accum_iter.cc: Added a test for this. - Bug #417926. - -2006-11-14 Daniel Elstner - - * autogen.sh: Wholly replace this script with a critter from one - of my personal projects, with slight modifications. This one does - some sophisticated stuff like probing version numbers of available - automake and aclocal executables, in order to choose the right one - accordingly. All this is necessary to make the build system work - robustly in custom environments such as Maemo where automake-1.9 - doesn't come preinstalled. - -2006-06-20 Murray Cumming - - * sigc++/adaptors/macros/bind.h.m4: - * sigc++/adaptors/macros/retype.h.m4: - * sigc++/functors/macros/functor_trait.h.m4: - * sigc++/functors/macros/slot.h.m4: - * sigc++/macros/retype.h.m4: - * sigc++/macros/signal.h.m4: Revert the previous changes, because none is - used in the exported symbol names from gtkmm, so this would break the ABI - of gtkmm. - -2006-05-26 Régis Duchesne - - * sigc++/adaptors/macros/bind.h.m4: - * sigc++/adaptors/macros/retype.h.m4: - * sigc++/functors/macros/functor_trait.h.m4: - * sigc++/functors/macros/slot.h.m4: - * sigc++/macros/retype.h.m4: - * sigc++/macros/signal.h.m4: - Renamed 'nil' to 'none' to allow an Objective-C++ compiler to compile - the library header files. - -2005-12-21 Murray Cumming - - * sigc++/macros/signal.h.m4: Make remaining - reverse_iterator_buf operator--() methods - return by reference, like the operator++() methods. - Bug #304402 from John Profic. - -2005-12-20 Murray Cumming - - * sigc++/macros/signal.h.m4: Make all operator--() methods - return by reference, like the operator++() methods. - Bug #304402 from John Profic. - -2005-12-14 John Profic - - * sigc++/macros/signal.h.m4: Fix compilation problem in - the last patch. - -2005-12-14 John Profic - - * sigc++/macros/signal.h.m4: Added emit_reverse(). - -This is the HEAD branch, for API/ABI-compatible API additions. -See also the libsigc-2-0 branch. - -2005-12-01 Murray Cumming - - * sigc++/functors/slot_base.cc: - slot_base::disconnect(): Set call_ to 0, - to invalidate the slot, even if parent_ is 0. - I think parent_ is, for instance, a signal, but - disconnect should still work on a slot that is not - connected to a signal, because a slot can be invoked - directly. - Fixes bug #311057 from James Lin. - -2005-12-01 Murray Cumming - - * tests/Makefile.am: - * tests/test_slot_disconnect.cc: Added test - case from bug #311057. - -2005-11-16 Philipp Berndt - - * sigc++/adaptors/macros/exception_catch.h.m4: Make member - exception_catch_functor::catcher_ - public so that it can be accessed by visit_each() - (bug fixed for generalization on 2004-11-06) - -2.0.16: - -2005-08-01 Neal E. Coombes - - * sigc++/signal_base.h: Updated the documentation for temp_slot_list - as requested in bug #303896. - -2005-08-01 Murray Cumming - - * sigc++/adaptors/hide.h.m4: Added missing - ) in call to sun_forte_workaround(), fixing - build on SUN Forte 5.5. Bug #312020. - -2005-08-19 Bruno Martinez - - * sigc++/type_traits.h: Renamed - ::sigc::is_base_and_derived::internal to - ::sigc::is_base_and_derived::internal_class - in order to avoid conflict with - namespace internal. - -2005-07-13 Murray Cumming - - * docs/manual/libsigc_manual.xml: Correct mentions of - 1.2 stuff instead of 2.0. Patch in bug #310213 from - pebble.org.uk. - -2005-07-13 Murray Cumming - - * docs/manual/libsigc_manual.xml: Fixed typo - found by Antonio Coralles. - -2005-07-09 Murray Cumming - - * sigc++/macros/signal.h.m4: Did the same (see - last commit) for slot_const_iterator and - slot_iterator_buf. - -2005-07-09 Murray Cumming - - * sigc++/macros/signal.h.m4: slot_iterator: - operator--() now returns value, not reference, like - operator++() already did. This caused crashes when - using --no-inline with g++. Bug #308651 by - Michael Andres. - -2.0.15: - -2005-07-04 Philip Langdale - - * sigc++/adaptors/macros/compose.h.m4: Add a setter typedef to - compose*_functor and use it instead of the (incorrect) getter - typedef in the compose* specialization of visit_each<>(). - This corrects the lifetime management of slots created with - compose(). Bug #308433. - -2005-06-13 Marek Rouchal - - * tests/test_deduce_result_type.cc: Specify int return type - for main(), to be more ISO C++ compliant. Bug #307478. - -2005-06-11 Andris Pavenis - - * sigc++/adaptors/lambda/macros/base.h.m4: - * sigc++/adaptors/lambda/macros/select.h.m4 - * sigc++/adaptors/macros/hide.h.m4: Specify only a type (not a - parameter name) for unused member function parameters - -2005-06-12 Paul Pogonyshev - - * configure.ac: - * scripts/cxx.m4: - * sigc++config.h.in: Add test for whether the compiler allows - referencing to member functions of the class/structure being - declared from a definition of a static member variable. - Supposedly a generic solution for GCC 3.2 compilation problems. - - * sigc++/type_traits.h: Define SIGC_WRAP_IS_BASE_CLASS_ based on - results of the above test. - (struct is_base_and_derived): Wrap up is_base_class_() functions - in an internal class if SIGC_WRAP_IS_BASE_CLASS_ is defined. - -2005-06-10 Murray Cumming - - * sigc++/adaptors/macros/bind.h.m4: - * sigc++/functors/macros/slot.h.m4: - * sigc++/macros/signal.h.m4: Use CALL_SIZE instead of - hard-coded 7s and 6s. - -2.0.14: - -2005-06-10 Murray Cumming - - * sigc++/visit_each.h: Make the - limit_derived_target::with_type inner class an outer class, - to satisfy the SUN CC 5.7 compiler, though I think it is a - compiler bug. Bug #302098 has the test case. - -2.0.13: - -2005-06-07 Murray Cumming - - * tests/test_compatibility.cc: Specify the actual class when - using test_int(), instead of the derived class, to fix the build - on SUN Forte CC 5.5. Patch from Friedemann Kleint in - Bug #305647 - -2005-06-07 Murray Cumming - - * sigc++/macros/signal.h.m4: signal_emit::emit(): Use scope to - ensure a certain order of destruction of the member variables, to - avoid a leak on MSVC++. Patch by Andreas Ames in Bug #306249. - -2005-06-07 Murray Cumming - - * sigc++/macros/signal.h.m4: Added comments about commenting-out - SIGC_TYPEDEF_REDEFINE_ALLOWED when using SUN Forte CC 5.7, - because I can not seem to create a test for it. - -2005-06-07 Murray Cumming - - * configure.ac: - * scripts/cxx_std.m4: - * sigc++/macros/signal.h.m4: - * sigc++config.h.in: Added check for - the non-standard SUN Forte reverse_iterator<>, - and used it. This is based on the same stuff in - gtkmm. - -2005-06-07 Murray Cumming - - * sigc++/visit_each.h: limit_derived_target(): Just some whitespace - changes. - -2005-05-16 Neal E. Coombes - - * sigc++/signal_base.h: Modified temp_slot_list to be a temporary view - into a slot list. Instead of emptying the original it now simply tacks - a placeholder to the end of the original. It then uses this as it's - 'end' iterator. This should allow for conscious recursiveness, as well - as inserting a slot to any position in the slot list during emittion. - See bug #303896. - -2005-06-04 Friedemann Kleint - - * sigc++/macros/limit_reference.h.m4: - visit_each() template specializations: - Mention the bool I_derives_trackable - template type, to fix the build on Solaris - Forte 5.5. - -2.0.12: - -2005-05-06 Régis Duchesne - - * sigc++/macros/limit_reference.h.m4 (added): - * sigc++/Makefile.am: - New class that just stores a reference, and makes sure that if the - reference derives from trackable, then the trackable reference will be - used instead of the derived reference in visit_each(). - * sigc++/functors/macros/mem_fun.h.m4: Better fix for bug #169225 by - Régis Duchesne and Christian Hammond, based on the new limit_reference - class. - * sigc++/adaptors/bound_argument.h (added): New class (built upon the - new limit_reference class) that handles all 3 kinds of bound arguments: - by value, by reference, and by constant reference. References are - unwrapped in the bound_argument's constructor. - * sigc++/adaptors/macros/bind.h.m4: Fix for bug #302327 by Régis - Duchesne. Bound arguments now need to know whether they are passed by - reference or not. So bind() now builds bind_functor instances using - 'reference_wrapper' types, instead of 'Foo &' types. The - bind_functor code is modified to compensate. - * sigc++/adaptors/macros/bind_return.h.m4: Similar fix for a similar - bug (unfiled) with bound return arguments. - * sigc++/reference_wrapper.h: - * sigc++/type_traits.h: - The reference_wrapper class is only used in bound_argument.h. Put - correct but unused code under #if 0. - * sigc++/adaptors/lambda/base.h: This file needs reference_wrapper.h, - but was incorrectly relying on type_traits.h to include it. - * tests/Makefile.am: - * tests/test_virtualbase_delete.cc (deleted): - * tests/test_virtualbase_delete_ref_param.cc (deleted): - * tests/test_limit_reference.cc (added): - Replaced test_virtualbase_delete*.cc with a simpler - test_limit_reference.cc which checks for all 3 aspects of the same bug - in one file. - * tests/test_bind_ref.cc: Slots must use 'Foo &' types. We were lucky - this broken usage worked before this change. The change in - type_traits.h made this bug obvious, by preventing the code to compile. - * tests/test_bind_return.cc: After my change, bind() and bind_return() - must use 'reference_wrapper' types. - * tests/test_custom.cc: Made this test a no-op (so it does not perturb - 'make check' on released versions of the library) and made it a - template ready to be modified by hackers. - -2005-05-01 Murray Cumming - - * sigc++/functors/slot_base.cc: - slot_base::slot_base(src): If the source - slot_base has a null rep->call_, meaning that the - slot is invalid, just return a default-constructed - slot, to prevent the crash shown in - tests/tests_copy_invalid_slot.cc. Bug #302515 by - Régis Duchesne. - -2005-05-01 Murray Cumming - - * sigc++/functors/macros/mem_fun.h.m4: bound_*<>: - Add a new is_base_and_derived - parameter to the template and thereby provide a - specialization for T_Obj types that derive from - sigc::trackable. This prevents a crash when casting - from the derived type to sigc::trackable after the - derived destructor has run. This cast can sometimes - fail when using multiple inheritance, at least with - g++. Bug #169225 by Régis Duchesne and Christian - Hammond. - * sigc++/type_traits.h: Add documenation for - the internal is_base_and_derived<> template, which - allows us to specialize other templates for certain - template types. - -2005-04-28 Murray Cumming - - * sigc++/type_traits.h: Added comments for users of - g++ 3.2. - -2005-04-28 Murray Cumming - - * tests/Makefile.am: - * tests/test_virtualbase_delete.cc: Added - simplified test case from bug #169225. We have a patch - to make this succeed but I am not ready to commit it - just yet. - -2005-04-27 Murray Cumming - - * tests/Makefile.am: - * tests/test_custom.cc: - Added a place to put extra test code, so I don't have - to keep installing my crazy libsigc++ versions. - -2005-04-27 Murray Cumming - - * sigc++/visit_each.h: Revert back to the non-explicit - template call, because we can not specify the - template specialization so easily, because the - specializations have different numbers of types. - * tests/Makefile/am: - * tests/test_bind_ref.cc: Add a simple test only for - sigc::ref disconnection. - -2005-04-26 Murray Cumming - - * sigc++/visit_each.h: Use the explicit template - specialization, needed for Tru64 and AIX compilers. - This causes a crash in some uses of sigc::ref() - (when using g++ 3.3.4 or 3.3.5 , but not with 3.4) but - seems to fix a crash in some uses of multiple inheritance - (bug #169225). - * tests/test_bind.cc: Comment out the crashing (not with - g++ 3.4) use of sigc::ref() with an explanatory comment. - -2.0.11: - -2005-03-09 Cedric Gustin - - * Makefile.am: Moved MSVC_Net2003 directory to SUBDIRS. - * MSVC_Net2003/Makefile.am: Added blank.cpp to EXTRA_DIST. - * MSVC_Net2003/libsigc++2_msvcNet2003.sln: Removed - test_accumulated and test_lambda projects as the tests are - disabled in the standard, configure-based build. - * MSVC_Net2003/MSVC_Net2003/libsigc++2_msvcNet2003.vcproj: - Generate a PDB file in the Debug target. - -2005-03-05 Murray Cumming - - * docs/website/stable.html: Mention actual supported compilers. - * docs/website/docs.html: Removed broken examples links. Change - reference link to the reference overview page. - -2005-02-23 Murray Cumming - - * sigc++/functors/slot_base.h: Make slot_base::operator=() public, to - fix the build with SUN Forte C++ 5.5 and Tru64. - -2.0.10: - -2005-02-20 Murray Cumming - - * tests/test_slot.cc, test_disconnect.cc: #included to avoid - an unresolved symbol error with the Tru64 compiler. Solution found by - Tim Mooney in bug #161503. - -2005-02-20 Martin Schulze - - * sigc++/signal_base.h: Add some documentation. - -2005-02-20 Martin Schulze - - * sigc++/signal_base.cc: Reset deferred_ flag to false in - signal_impl::sweep() (Neal E. Coombes). Partly fixes bug #167714. - -2005-02-11 Martin Schulze - - * docs/manual/Makefile.am: Set the correct group in post-html. - -2005-02-11 Murray Cumming - - * docs/website/doc.shtml: Fix typo in url for reference docs. Found by - James Lin. - -2005-02-06 Murray Cumming - - * sigc++/signal_base.h: temp_slot_list::begin(), end(): Actually - return the iterators. - -2005-02-03 Neal E. Coombes - - * sigc++/signal_base.h: Add temp_slot_list struct to facilitate - allowing new connections to a signal during an emittion without - affecting that emittion. - * sigc++/macros/signal.h.m4: Use the new struct temp_slot_list to - prevent connections made during an emittion from being called in the - same emittion (which has the potential of causing things like - infinite loops). This guarantees an emittion will be finite, as well - as maintaining any order of emittion guarantees that may have already - been in place. - -2.0.9: - -2005-02-02 Murray Cumming - - * sigc++/visit_each.h: visit_each_type(): Reverted the change, so that - we do not specify the template types ot visit_each<>(), because it - crashes on g++ 3.3.4 (but not g++ 3.4.2). Added a comment telling users - of AIX (and maybe IRIX MipsPro and Tru64) to use the alternative version - if they have compilation problems. - -2005-02-01 Murray Cumming - - * sigc++/adapators/macros/base.h.m4: Add sigc::var<>() documentation, - from Roger Ferrer Ibáñez in bug #149483. - -2005-02-01 Murray Cumming - - * sigc++/adaptors/macros/compose.h.m4: In the template specializations - of visit_each(): As before, specify the specific other template - specializations of visit_each that we use. Needed by AIX. - * tests/Makefile.am: Reenabled most tests, because AIX can now - build them. - -2005-02-01 Murray Cumming - - * sigc++/visit_each.h: visit_each_type(): Specify the specific - template specialization of visit_each<>() to use. The AIX compiler, - and possibly the Tru64 compiler, need this extra hint. - -2005-02-01 Murray Cumming - - * bind.h.m4: Define bind_functor::operator() inline because the AIX - compiler/linker sometimes fails to find it when it is defined - outside of the class. - -2.0.8: - -2005-01-30 Murray Cumming - - * sigc++/type_traits.h: is_base_and_derived: Added - avoid_gcc3_warning_(), to avoid an incorrect warning when using - g++ 3.3.5 - -2005-01-28 Liza Klerck - - * sigc++/functors/macros/mem_fun.h.m4: Add a sigc:: namespace - prefix to the nested use of visit_each(), to avoid ambiguity when - using 2 versions of the libsigc++ API inside different namespace. - -2005-01-27 Murray Cumming - - * sigc++/adaptors/macros/adaptor_trait.h.m4: Add a sigc:: namespace - prefix to the nested use of visit_each(), to avoid ambiguity when - using 2 versions of the libsigc++ API inside different namespace, - which is not very advisable anyway. Bug #165222 from - liza at trdlnk.com. - -2.0.7: - -2005-01-24 Cedric Gustin - - * sigc++config.h.in : Moved the SIGC_USING_STD macro definition - out of the SIGC_CONFIGURE section. We also need it for MSVC. - * MSVC_Net2003/.cvsignore : Added .def and .aps files - * MSVC_Net2003/Makefile.am: Rewrote rule for local copy of - sigc++config.h (required for 'make distcheck'). - * MSVC_Net2003/libsigc++2_msvcNet2003.sln: Added test_retype and - test_disconnect_during_emit tests. - * MSVC_Net2003/tests/test_disconnect_during_emit/*, - MSVC_Net2003/tests/test_retype/*: Initial commit. - -2005-01-21 Murray Cumming - - * tests/: Disabled the test_accumulator, test_bind, and test_compose - tests, and part of test_mem_fun because the AIX xlC compiler can not - build them, but it can still do most things, including the examples. - See the comments in tests/Makefile.am. - -2005-01-21 Murray Cumming - - * sigc++/adaptors/bind.h.m4: non-member operator()(): Specify the - extra nil arguments in the templated class name prefix. Oddly, the - AIX xlC compiler says that the type of the first parameter does not - match the template if you don't do this. - -2005-01-21 Murray Cumming - - * sigc++/type_traits.h: is_base_and_derived struct: Move the - is_base_class_() functions out of the inner class, because the AIX - xlC compiler does not like that - see the comments in the code. - * sigc++/adaptors/bind.h.m4: Add the extra nil template types to - the template specializations, as in slot and signal. - -2005-01-21 Murray Cumming - - * sigc++/functors/macros/slot.h.m4, sigc++/macros/signal.h.m4: - slot and signal template specialization for - various numbers of template args: In the class slot line, specify - all the remaining template types as null, instead of expecting the - compiler to guess them in itself. This partly fixes the build on - AIX with the xlC compiler. Bug #164685. - -2005-01-19 Murray Cumming - - * sigc++/type_traits: struct is_base_and_derived: Make the test inner - struct a friend, so that it can use the big inner struct. This is - required by the Tru64 compiler. - * sigc++/adaptors/lambda/base.h: Put the unwrap_lambda_value() - definitions at the top, because Tru64 (understandably) needs them to - be declared before use. - -2005-01-19 Murray Cumming - - * scripts/: Added cxx_std.m4, with a test copied from - glibmm/scripts/cxx_std.m4 to check if the compiler has the std:: - namespace. - * sigcconfig.h: #undef the new #define and add SIGC_USING_STD(), - like GLIBMM_USING_STD, to put stuff in the std:: namespace when it - is not there already, - * configure.in: Used the new test. - * tests/*: Uses SIG_USING_STD() for every std:: thing that we use. - This is needed by the Tru64 and HP-UX compilers when using their - defaults. - -2005-01-19 Murray Cumming - - * configure.in: AC_INIT(): Provide the extra tarball name parameter, - so that it does not create a libsigc--- tarball. - -2005-01-19 Murray Cumming - - * configure.in: AC_INIT(): Use libsigc++ instead of sigc++, attempting - to get the correct tarball name. - -2005-01-18 Murray Cumming - - * configure.in: Used the autoconf 2.93 and AM_INIT_AUTOMAKE() - technique to specify ustar format for the tarball, to prevent files - with long file names from appearing at the top of the tarball. - Based on the same fix in gtkmm 2.6. - -2005-01-18 Murray Cumming - - * sigc++/functors/macros/slot_h.m4: Specify the base class when - using the rep_ member variable. This stops the HP-UX aCC compiler - from saying that a Nonstatic member is referenced in a nested class, - local class or static member initializer. Bug #150719. - -2005-01-18 Murray Cumming - - * Bug #159597 - patch from e97_far at e.kth.se to replace C-style - casts with reinterpret_cast<> and static_cast<> to avoid warnings. - -2005-01-17 Murray Cumming - - * docs/manual/Makefile.am: Specifying html/index.html instead of - just the html directory as a target seems to fix distcheck problems. - I can also now confirm that the install works on solaris, when using - gmake, though not when using make. - -2005-01-17 Murray Cumming - - * MSVC_Net2004/Makefile.am: Add built files to DISTCLEANFILES to fix - the distcheck. - * docs/reference/Makefile.am, manual/Makefile.am: Specify $srcdir in - paths, to fix distcheck of the manual, and maybe fix install problems - on Solaris. - -2005-01-11 Murray Cumming - - * docs/website/stable.html: Updated the text about binary packages. - * docs/website/docs.html: Link to the 2.0 documentation instead of the - 1.2 documentation. - -2004-12-17 GregSchussman - - * glossary.shtml: Clean up punctuation, make definitions complete - sentences, and add clarifications for certain definitions according to - what Murray Cumming's suggestions and answers to my questions. - Bug #161580. - -2005-01-11 Murray Cumming - - * docs/: Added manual, copied from the libsigc++-1.2 cvs module, - and updated it for the new 2.0 API. - -2005-01-11 Murray Cumming - - * docs/: Added website, copied from the libsigc++-1.2 cvs module. - We will use it from here from now on. - -2004-12-11 Cedric Gustin - - * configure.ac : parse version tags at configure time (for - sigc-2.0.rc). - * MSVC_Net2003/sigc-2.0.rc.in : New resource file. - * MSVC_Net2003/Makefile.am: include sigc-2.0.rc in distribution. - -2004-12-08 Cedric Gustin - - * MSVC_Net2003/Makefile.am: get sigc++config.h from $(top_builddir) - instead of $(top_srcdir). - -2004-12-08 Cedric Gustin - - * MSVC_Net2003/*/*.vcproj: Renamed libsigc++ target to - sigc-2.0d.dll (Debug) and sigc-2.0.dll (Release). Added - $(SolutionDir) and $(SolutionDir)\.. to "Additional Include - Directories" in tests projects. - * sigc++config.h.in: Rewrote dllexport/dllimport macros for - MSVC, for better consistency with glibmm/gtkmm. - * MSVC_Net2003/Makefile.am: copy sigc++config.h from $(top_srcdir) - at build time. - -2004-11-27 Murray Cumming - - * configure.in: Revert the AC_PROG_LIBTOOL change, so that this builds - with actually released libtool versions, and in jhbuild, so that it - gets testing. - -2004-11-06 Martin Schulze - - * sigc++/adaptors/macros/exception_catch.h.m4: Make catcher_ member - public so that it can be accessed by visit_each() (bug reported on - ml by Philip Langdale ). - -2004-10-24 Martin Schulze - - * MSVC_Net2003/*/*.vcproj: Link with the "multithreaded DLL" runtime - libraries and enable RTTI for the MSVC build - (patch from Timothy M. Shead ). - * MSVC_Net2003/*/.cvsignore: Hide generated build files from cvs - (patch from Timothy M. Shead ). - -2.0.6: - -2004-10-12 Martin Schulze - - * MSVC_Net2003/*/*.vcproj, MSVC_Net2003/blank.cpp: Fix project files - to compile out-of-the-box and add dummy file so that .cc files get - recognized as c++ code files (patch from Timothy M. Shead). - -2004-10-10 Martin Schulze - - * sigc++/signal_base.{h,cc}, sigc++/functors/slot_base.{h,cc}, - sigc++/functors/macros/slot.h.m4: If SIGC_NEW_DELETE_IN_LIBRARY_ONLY - is defined, implement signal_base::operator new/delete and - slot_rep::operator new/delete (suggested by Timothy M. Shead). - Remove old work-around from 2004-10-02 since it didn't work. - -2004-10-07 Martin Schulze - - * configure.ac: Update for libtool 1.5a (with support for Intel C++). - * MSVC_Net2003/sigc++config.h: Remove bogus '#define' - (reported by Timothy M. Shead ). - -2004-10-02 Martin Schulze - - * configure.ac: Bump version number to 2.0.6. - * NEWS: Add ChangeLog summary for version 2.0.6. - -2004-10-02 Martin Schulze - - * sigc++/functors/slot_base.{h,cc}, sigc++/functors/macros/slot.h.m4: - Rename (typed_)slot_rep::detach to (typed_)slot_rep::destroy. - Call the dtor of the functor stored in typed_slot_rep from destroy(). - A cleaner solution would be to add an additional "virtual" function - that calls 'delete' or a real virtual dtor. However, this would be - less efficient and might break the ABI. (Fixes #152323.) - -2004-10-02 Martin Schulze - - * sigc++config.h.in, MSVC_Net2003/sigc++config.h, - sigc++/signal_base.cc, sigc++/functors/slot_base.{h,cc}, - sigc++/functors/macros/slot.h.m4: Define and use new macro - SIGC_NEW_DELETE_IN_LIBRARY_ONLY to ABI-compatibly move - all calls to new and delete into non-inline library code. - -2004-09-26 Martin Schulze - - * sigc++/adaptors/lambda/macros/group.h.m4: Add a missing - template keyword in the definition of deduce_result_type::type - (hopefully fixes #152327). - -2004-09-26 Martin Schulze - - * sigc++/macros/object_slot.h.m4: Use correct bound_mem_functor - variants for const (volatile) methods (fixes #148744). - -2004-09-01 Martin Schulze - - * docs/index.html: Correct link to lambda module. - -2004-09-01 Martin Schulze - - * README: Update compatibility section. - -2.0.5: - -2004-09-01 Martin Schulze - - * MSVC_Net2003/Makefile.am: Add sigc++config.h to EXTRA_DIST. - * configure.ac: Bump version number to 2.0.5. - * NEWS: Add ChangeLog summary for version 2.0.5. - -2.0.4: - -2004-08-21 Martin Schulze - - * tests/test_lambda.cc: Use sigc::var("\n") instead of sigc::ref("\n"). - Comment out the affected lines, nevertheless. - Sun FORTE and Compaq C++ can handle neither sigc::ref("\n") nor - sigc::var("\n"). I see more chances fixing sigc::var("\n"). - * sigc++/adaptors/lambda/macros/base.h.m4: Add a comment about a - possible work around for sigc::var("\n") compiler problems. - * tests/test_compatibility.cc: Remove a 'const' keyword that prevents - the test case from compiling with the Sun FORTE. - * tests/test_trackable.cc: Remove a 'virtual' keyword and an unused - variable to avoid compiler warnings. - * NEWS: Add ChangeLog summary for version 2.0.4. - -2004-08-03 Martin Schulze - - * scripts/cxx.m4, sigc++config.h.in, configure.ac, - sigc++/adaptors/lambda/macros/operator.h.m4, tests/test_lambda.cc: - Rollback change from 2004-07-15: configure check - SIGC_OPERATOR_OVERLOAD_AMBIGUITY is not needed - the overload - ambiguity doesn't occur if the lambda operators take all arguments - as const reference. - * configure.ac: Bump version number to 2.0.4. - -2004-08-03 James Lin - - * Added SIGC_API qualifier to all externally-visible non-template - classes/structs. - * Added #include to the files that use SIGC_API. - * Added empty SIGC_API definition to sigc++config.h.in for non-MSVC - compilers. I'm not sure if this is the right place to put this - (probably not). - * Added MSVC-specific sigc++config.h to the MSVC project directory. - (The comment in it probably should be edited.) - * Changed MSVC project settings to output a multi-threaded DLL, set - the include paths to work (hopefully) out-of-the-box. Disabled - precompiled headers, since they just complicate things and - shouldn't be necessary for such a relatively project. - -2004-08-01 Martin Schulze - - * sigc++/type_traits.h: Remove type_trait<>::instance() - (was unimplemented and unused; caused problems with the MSVC). - -2004-07-23 Martin Schulze - - * Makefile.am: Fix typo concerning distribution of libsigc++-2.0.spec. - * AUTHORS: Mention our contributors for platforms Sun FORTE and Intel C++. - -2004-07-15 Martin Schulze - - * *.h.m4: Don't call operator()() in sun_forte_workaround(); rather copy - operator()(). Calling operator()() makes a copy of the arguments causing - wrong results if an argument type is a reference. Hopefully fixes #147311. - -2004-07-15 Martin Schulze - - * tests/test_lambda.cc: Break "std::cout << [expr] << a << std::endl;" - into "std::cout << [expr]; std::cout << a << std::endl;". - I hope this fixes #147313 where the right values for "[expr]" but wrong - values for "a" were written to std::cout for some compiler with optimizations - turned off. - -2004-07-15 Martin Schulze - - * sigc++/adaptors/lambda/macros/operator.h.m4: Correct return type deduction - of lambda expressions in lambda_operator*::operator()(). Might be related to - bug #147313. - * sigc++/adaptors/lambda/macros/group.h.m4: Use m4 macro _P_(). - -2004-07-15 Martin Schulze - - * scripts/cxx.m4, sigc++config.h.in, configure.ac, - sigc++/adaptors/lambda/macros/operator.h.m4, tests/test_lambda.cc: - Add configure check SIGC_OPERATOR_OVERLOAD_AMBIGUITY for a SUN FORTE - compiler problem (bug #147391). Use it to decide whether the lambda - action operators may be overloaded (not doing so restricts the API slightly). - * sigc++/adaptors/lambda/macros/operator.h.m4: Add some doxygen comments - and remove attic code. - * sigc++/adaptors/lambda/macros/base.h.m4: - Add templates unwrap_lambda_type and unwrap_lambda_value() to support - the non-overloaded lambda action operators. Also add some doxygen comments - and remove attic code. - * sigc++/adaptors/lambda/macros/group.h.m4: Fix a bug that resulted in - gargabe values being passed on to the functor contained in the group adaptor - (partly fixes #147313). - -2004-07-11 Martin Schulze - - * scripts/cxx.m4, sigc++config.h.in, configure.ac, *.h.m4: - Split SIGC_CXX_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - into SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - and SIGC_CXX_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD. - Remove LIBSIGC_TEMPLATE_PREFIX. Add template keyword to - SIGC_WORKAROUND_OPERATOR_PARENTHESES depending on the configure checks. - Should fix the compiler problems with MSVC. - -2004-07-11 Martin Schulze - - * examples/hello_world.cc: Use sigc::ptr_fun instead of std::ptr_fun. - (fixes bug #144846) - -2004-07-11 Eric Bourque - - * libsigc++-2.0.spec.in: new file - * configure.ac : patched generate spec file - * .cvsignore: ignore generated file (Martin Schulze) - * Makefile.am: distribute spec file (Martin Schulze) - -2004-07-11 Murray Cumming - - * sigc++/connection.cc: Added some comments. - * sigc++/trackable.cc: operator=(): Check for self-asignment, though I - do not know of any actual bug that this fixes. Added some comments. - * sigc++/trackable.h Added some doxygen documentation. - -2004-07-09 Murray Cumming - - * tests/: Added test_disconnect_during_emit.cc, to prove that this - works. - -2004-07-08 Murray Cumming - - * tests/test_retype_return.cc: foo::operator(int): return a - value. The SUN Forte 5.5 compiler complains about this, as it should. - -2004-07-08 Murray Cumming - - * sigc++/macros/signal.h.m4: class signal*: Rename the slot_list - typedef to slot_list_type, because there is already a template class - called slot_type. SUN Forte 5.5 seems to complain about this and I am - not surprised. The old typdef is still there for backwards - compatibility, except when building with SUN Forte. - -2004-07-07 Murray Cumming - - * scripts/cxx.m4: SIGC_CXX_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD(): - Don't define the SIGC_TEMPLATE_SPECIALIZATOIN_OPERATOR_OVERLOAD C - macro at all if the test fails. This might fix the build on SUN Forte. - * sigc++/functors/macros/mem_fun.h.m4: Default constructor: Initialize - the func_ptr_ member variable. I have no evidence that this solves any - problems, but it worried me. - * sigc++/functors/slot_base.h: operator bool(): Correct documentation, - to use @code instead of - * sigc++/macros/signal.h.m4: Remove the documentation for the - parameters named first and last, because they do not exist. - -2004-05-31 Martin Schulze - - * autogen.sh: Add '--force'-flag to the 'libtoolize'-command (bug #143425). - -2.0.3: - -2004-05-30 Martin Schulze - - * configure.ac: Bump version number to 2.0.3. - * NEWS: Add ChangeLog summary for version 2.0.3. - * sigc++/macros/signal.h.m4: Fix segfault on emission of unconnected signal. - * tests/test_signal.cc, tests/test_accumulated.cc: Emit unconnected signal. - * sigc++/macros/object_slot.h.m4: Suppress compiler warning at - dynamic_cast<>-test (tested by Christof Petig/Timothy M. Shead). - -2.0.2: - -2004-05-22 Martin Schulze - - * configure.ac: Bump version number to 2.0.2. - * NEWS: Add ChangeLog summary for version 2.0.2. - -2004-05-20 Martin Schulze - - * sigc++/macros/signal.h.m4: If a custom accumulator is specified - invoke it on signal emission even if the signal's slot list is empty. - (This used to be the case in libsigc++-1.2 as pointed out by Timothy.) - -2004-05-20 Martin Schulze - - * sigc++/macros/object_slot.h.m4: Suppress compiler warning at - dynamic_cast<>-test (suggested by Timothy M. Shead). - -2004-05-01 Martin Schulze - - * README: Updated for libsigc++-2.0. - -2.0.1: - -2004-04-27 Martin Schulze - - * configure.ac: Bump version number to 2.0.1. - * NEWS: Add ChangeLog summary for version 2.0.1. - * sigc++/adaptors/lambda/macros/base.h.m4: Fixed documentation. - * sigc++/adaptors/macros/bind.h.m4: Hide work-arounds from doxygen. - * scripts/cxx.m4, sigc++config.h.in, configure.ac, - sigc++/adaptors/macros/bind.h.m4: Removed configure check. It - showed that the Apple gcc can also compile the sophisticated version - of the work-around. - -2004-04-26 Martin Schulze - - * sigc++/macros/object_slot.h.m4: Modified test for SigC::Object - inheritance so that it also works if SigC::Object is virtual base. - (Fixes bug 141094 reported by Jonathan Brandmeyer) - -2004-04-26 Martin Schulze - - * scripts/cxx.m4: Updated the configure check. It would probably - have succeeded on the Apple. - -2004-04-26 Martin Schulze - - * sigc++/adaptors/macros/bind.h.m4: Add work-arounds for - bind<-1>::deduce_result_type compilation error on Apple gcc 3.3. - * scripts/cxx.m4, sigc++config.h.in, configure.ac: Add configure - check for the compilation error above. - * sigc++/adaptors/lambda/macros/operator.h.m4: Replace _A with - _Aa. _A is a reserved keyword on Apple gcc 3.3 (Spundun Bhatt). - (fixes bug #10444 reported by Spundun Bhatt) - -2004-04-19 Martin Schulze - - * sigc++/signal_base.cc: Fixed serious bug in signal_base::impl(): - Only reference a newly created object (initial reference). - (This fixes bug #140269 reported by Andris.) - -2004-04-19 Murray Cumming - - * scripts/cxx.m4: Updated the operator() template check, because it - failed with gcc 3.4 (from cvs). Apparently the template keyword can - only be used from another template. - -2.0.0: - -2004-04-06 Martin Schulze - - * configure.ac: Bump version number to 2.0.0. - * NEWS: Add ChangeLog summary for version 2.0.0. - * TODO, AUTHORS: Bring up to date. - * sigc++-2.0.pc.in, Makefile.am: 1.9 -> 2.0 - * Added more documentation. - -2004-04-10 Murray Cumming - - * sigc++/connection.[h|cc]: Implement blocked() to avoid undefined - symbol linker error. - -2004-04-08 Murray Cumming - - * dist the scripts directory. - -1.9.16: - -2004-04-06 Martin Schulze - - * configure.ac: Bump version number to 1.9.16. - * NEWS: Add ChangeLog summary for version 1.9.16. - -2004-04-02 Murray Cumming - - * sigc++/connection.cc: Make block() and unblock() always return a - value, to fix compiler warnings. Patch from bug #138620 by - Alexander Nedotsukov. - -2004-04-02 Murray Cumming - - * Fix the compile of examples/member_method.cc. Bug #131701 from - Kirill Smelkov. I also made the examples build as part of the regular - build. - -2004-04-02 Murray Cumming - - * sigc++config.h.m4: Remove every undef apart from the one we need, to - avoid clashes, because we #include this in a public header. - -2004-03-25 Murray Cumming - - * scripts/cxx.m4, configure.in, sigc++config.h.in: Rename the - template_keyword check to template_specialization, because the problem - is with or without the keyword. - * sigc++/adaptors/macros/adaptor_trait.h.m4: Define - SIGC_WORKAROUND_OPERATOR_PARENTHESES, which calls either operator() or - sun_forte_workaround() depending on the result of the compiler test. - * many .m4 files: Add sun_forte_workaround methods that call the - operator() methods. Put them in #ifdefs so that only SUN Forte C++ - sees them. - -2004-03-22 Murray Cumming - - * Makefile.am, sigc++/Makfile.am: Fix the sigc++config.h.in disting, - to fix make distcheck. - -2004-03-21 Murray Cumming - - * Rename config.h.in to sigc++config.h.in so that gtkmm does not - include some other config.h at strange times - fixes a problem in - the gtkmm demos. This should really be in the sigc++ directory, but - that seems to add that as an include path, which causes the STL - headers to include sigc++/signal.h instead of some STL signal.h header. - -2004-03-20 Murray Cumming - - * Makefile.am: Install the config.h platform-specific header. - * sigc++-2.0.pc.in: Report the include path for config.h - -2004-03-20 Murray Cumming - - * Added config.h.in, using autoheader, from which config.h will be - generated, so we can detect compiler features. - * configure.ac: Added AC_CONFIG_HEADER(config.h) to generate config.h - from config.h.in. - * scripts/cxx.m4: Added this directory and file, with a - SIGC_CXX_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD macro that defines - the SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD C macro. - * autogen.sh: Added -I scripts to the aclocal call, so that it finds - the m4 macro for configure.ac. - * sigc++/adapators/macros/adaptor_trait.h.m4: Include config.h and - use SIGC_TEMPLATE_KEYOWRD_OPERATOR_OVERLOAD. - -2004-03-18 Martin Schulze - - * tests/test_mem_fun.cc, tests/test_ptr_fun.cc: Don't test - making functors from overloaded methods with partial template - specialization. Not portable among different compilers (SUN FORTE). - * adaptors/macros/apdaptor_trait.h.m4: Only gcc seems to use the - notation A.template operator()<...>(...) => adapt preprocessor check - for #define LIBSIGC_TEMPLATE_PREFIX. TODO: replace with configure check. - -2004-03-13 Murray Cumming - - * g++ 3.4 (pre-release) build fixes: - * sigc++/macros/signal.h.m4: slot_iterator_buf::operator*(): - Use blocked() and empty() instead of non-existant blocked_and_empty(). - * sigc++/functors/macros/mem_fun.h.m4: memfun_functor*::operator()(): - Use this->func_ptr_ instead of just func_ptr_. - * sigc++/adaptors/macros/deduce_result_type.h.m4: Use - T_functor::template deduce_result_type<> instead of just - T_functor::deduce_result_type<>. - * sigc++/adaptors/lambda/macros/base.h.m4, operator.h.m4, group.h.m4:: - Use template keyword again. operator[](): Use this->value_ instead of - just value_. - * sigc++/adaptors/lambda/macros/bind/m4: Use template keyword, and - this-> again. - * sigc++/adaptors/macros/compose.h.m4, hide.h.m4, bind_return.h.m4, - exception_catch.h.m4: - rettype.h.m4, rettype_return.h.m4: Use template keyword,and this-> again - -1.9.15: - -2004-02-27 Martin Schulze - - * configure.ac: Bump version number to 1.9.15. - * NEWS: Add ChangeLog summary for version 1.9.15. - -2004-02-27 Martin Schulze - - * sigc++/functors/macros/slot.h.m4: Make the unnumbered slot templates' - copy ctors use the copy ctors of the base class. Fixes bug #24698. - * tests/test_slot.cc: Test copy ctor (Bryan Forbes). - -2004-02-27 Martin Schulze - - * tests/type_functor_trait.cc: Bring it up-to-date (use sigc::ref). - Make it work with the SUN Forte. - -2004-02-24 Martin Schulze - - * sigc++/type_traits.h: Make is_base_and_derived<> work with the SUN Forte. - -2004-02-19 Martin Schulze - - * sigc++/type_traits.h: Make is_base_and_derived<> platform independant. - * sigc++/adaptors/lambda/macros/base.h.m4: Make lambda_core<> ctors - explicit. Remove an unused ctor from lambda_core. - -2004-02-14 Martin Schulze - - * sigc++/functors/slot_base.h, sigc++/functors/macros/slot.h.m4: - Move some documentation to slot_base.h. - * sigc++/signal_base.h, sigc++/macros/signal.h.m4: - Move some documentation to signal_base.h. - - API addition: - * sigc++/functors/macros/slot.h.m4: Add numbered slot# templates. - Make unnumbered slot templates inherit from slot#. - - API change: - * sigc++/functors/macros/mem_fun.h.m4: Allow for methods of the object's - base types to be passed into sigc::mem_fun(). (Used to be the case in - libsigc++-1.2). - -2004-02-13 Murray Cumming - - * sigc++/functors/slot_base.[h|cc], sigc++/trackable.[h|cc]: Create - and use a typedef for the destroy_notify callback functions, to avoid - confusion function pointer declaration syntax in the API. - -2004-02-13 Murray Cumming - - * Moved implementation to .cc files: - * sigc++/functors/: Added slot_base.[h|cc] which contains non-template - code that was previsouly in the generated functors/slot.h and - non-generated slot.cc files. All non-inline implementation is now in - the .cc file. - * sigc++/functors/macros/slot.m4: Removed the code that has been moved - to slot_base.[h|cc]. - * sigc++/: Added signal_base.[h|cc] which contains non-template code - that was previously in the generated signal.h and non-generated - signal.cc file. All non-inline implementation is now in the .cc file. - * sigc++/macros/signal.m4: Removed the code that ahs been moved to - signal.cc - * sigc++/connector.[h|cc]: method implementation moved to the .cc file. - -1.9.14: - -2004-02-13 Martin Schulze - - * configure.ac: Bump version number to 1.9.14. - * NEWS: Add ChangeLog summary for version 1.9.14. - -2004-02-09 Murray Cumming - - * sigc++/functors/macros/slot.h.m4: slot_base: Added operator bool(), needed to - check for a slot that is created with the default constructor. This was - present in libsigc++ 1.2 also. - -2004-02-06 Murray Cumming - - * Makefile.am: Build the docs directory, by adding it to SUBDIRS. - * docs/Doxyfile.in: Updated to be more glibmm-like. - * Added some @deprecated doxygen bits. - * sigc++/macros/signal.h.m4: Call base constructor from signal_base - constructor - this is an error-as-warning when building gtkmm. - -1.9.13: - -2003-11-30 Martin Schulze - - * configure.ac: Bump version number to 1.9.13. - * NEWS: Add ChangeLog summary for version 1.9.13. - * Makefile.am, MSVC_Net2003/Makefile.am, configure.ac: - Distribute MS .Net project files. - * sigc++/adaptors/macros/[bind,hide].h.m4: Correct and add - documentation. Make hide_functor ctor explicit. - -2003-11-11 Martin Schulze - - * sigc++/adaptors/macros/[bind,hide].h.m4: Change to zero-based - argument index in numbered bind() and hide() overload - (Agreement on the mailing list). - Support binding up to CALL_SIZE arguments with one bind adaptor. - (Requested by joey yandle and others). - Only support binding of multiple arguments in unnumberd overloads - to keep the API simple (Requested by Murray Cumming). - * tests/test_[bind,hide,functor_trait].cc, sigc++/bind.h: - Reflect API changes in compatibility module and test cases. - -2003-11-10 Martin Schulze - - * sigc++/adaptors/macros/[bind,hide].h.m4: Add unnumbered - bind() and hide() overloads to make specifying the argument - position optional (Proposed by Jeff Franks). - * tests/test_[bind,hide].cc: Test unnumbered bind() and hide(). - * sigc++/adaptors/macros/adaptor_trait.h.m4: - Change "#ifdef MSVC" to "#ifdef _MSC_VER" (Roel Vanhout). - -2003-11-09 Martin Schulze - - * sigc++/functors/macros/slot.h.m4: Change functor type in - typed_slot_rep to adaptor_trait::adaptor_type - and use explicit function template instantiation in - internal::slot_call::call_it(). Avoids copying of arguments - in call_it() and enables binding of object instances - to class methods through bind() (Reported by Jeff Franks). - * tests/test_bind.cc: Test binding object instances to - class methods through bind(). - * sigc++/adaptors/adaptors.h: Include retype[_result].h. - * sigc++/adaptors/macros/adaptor_trait.h.m4: - - Add documentation. - - Mark some c-tors as explicit. - - Remove ununsed operator T_functor&() from adaptor_functor. - * sigc++/adaptors/macros/deduce_result_type.h.m4: - Rewrite parts of the documentation. - * sigc++/adaptors/macros/bind.h.m4: Add documentation. - * sigc++/functors/macros/mem_fun.h.m4: Remove unnecessary - explicit markers. Minor fixes to documentation. - * sigc++/functors/macros/functor_trait.h.m4: - Minor fixes to documentation. - -1.9.12: - -2003-11-04 Martin Schulze - - * configure.ac: Bump version number to 1.9.12. - * NEWS: Add ChangeLog summary for version 1.9.12. - -2003-11-03 Martin Schulze - - * sigc++/macros/signal.h.m4: Document accumulators. - Move slot_iterator_buf into namespace internal. Since - accumulators have the iterator type as a template argument - there is no need to expose this very internal type. - * sigc++/functors/macros/*.m4: Regroup documentation. - Documentation of the core parts of the library should be - complete by now. - -2003-11-02 Martin Schulze - - * Improve documentation of the core parts of the library. - * tests/test_ptr_fun.cc: Test ptr_fun() with static - member functions. - -2003-11-02 Martin Schulze - - * Move all .m4 files into new subdirectories - sigc++/[...]/macros. Install the .m4 files on - "make install" (Reported by Ron Steinke). - -2003-11-01 Martin Schulze - - * sigc++/[class,method,object]_slot.h.m4: Include - sigc++/functors/mem_fun.h (Reported by Ron Steinke). - -2003-11-01 Martin Schulze - - * sigc++/adaptors/lambda/operator.h.m4: Add negation - operator I have completely overlooked until now. - * sigc++/tests/test_lambda.cc: Test negation operator. - -2003-11-01 Martin Schulze - - * sigc++/[class_slot,method_slot,object_slot,hide].h.m4, - sigc++/signal.h.m4, sigc++/functors/mem_fun.h.m4: - - Use a shorter notation for ..._mem_function variants. - - Change order of mem_funcotr<>'s template arguments to - match std::mem_fun_t and to be more consistent with adaptors. - - Use ::sigc::slot's implicit ctor in compatibility module. - * sigc++/adaptors/lambda/operator.h.m4: Change some - lambda action names to match action names in std. - - API addition: - * sigc++/adaptors/retype.h.m4: New file adding - adaptor retype. - * sigc++/Makefile.am: Build and distribute new file. - * tests/test_retype.cc: New file testing adaptor retype. - * MSVC_Net2003/tests/test_retype/test_reytype.vcproj, - tests/Makefile.am: Build and distribute new test case. - -2003-11-01 Martin Schulze - - * MSVC_Net2003: New directory containing project - files for Visual Studio .Net 2003. - Credits to Roel Vanhout ! - -2003-11-01 Martin Schulze - - * sigc++/retype.h.m4: Use LIBSIGC_TEMPLATE_PREFIX - in explicit function template instantiations. - * sigc++/type_traits.h: Add template specialization - for arrays (T_type[N]) to disable non-working member - type_trait::instance(). - * sigc++/visit_each.h: Remove more disturbing - limit_derived_target<>::operator() overloads. - (Should have noticed earlier that they are unnecessary.) - * sigc++/adaptors/deduce_result_type.h.m4, - sigc++/adaptors/lambda/operator.h.m4, - sigc++/functors/functor_trait.h.m4, - tests/test_[bind,compose,exception_catch,hide,lambda].cc: - Completely removed support for typeof(). We don't need - it any more and it is completely non-standard! - -2003-10-30 Cedric Gustin - - * configure.ac: Added test of win32 platform. Commented - out AM_DISABLE_SHARED (DLLs are shared libraries). - * sigc++/Makefile.am: added a few LDFLAGS for win32 - DLLs. - -2003-10-30 Martin Schulze - - * sigc++/signal.h.m4: Add SigC::Signal#<>::slot(). - * sigc++/slot.h.m4: Comment out make_slot() work-around. - * sigc++/adaptors/bind.h.m4: Remove unnecessary brackets - in template argument lists. They are confusing MSVC. - * sigc++/adaptors/*.h.m4, sigc++/adaptors/lambda/*.h.m4: - Use LIBSIGC_TEMPLATE_PREFIX in explicit function - template instantiations. - * sigc++/tests/test_*.cc: - - Include where std::string is used. - - Use double instead of float. - -2003-10-27 Martin Schulze - - * sigc++/retype.h.m4: Cleanup. - * TODO: Bring it up to date. - -1.9.11: - -2003-10-26 Martin Schulze - - * configure.ac: Bump version number to 1.9.11. - * NEWS: Add ChangeLog summary for version 1.9.11. - -2003-10-26 Martin Schulze - - Compatiblity module: - * sigc++/signal.h.m4: Move definition of compatiblity - classes SigC::SignalN to here. - * sigc++/connection.h: - - Add connection::connected(). - - Add compatibility typedef SigC::Connection. - * sigc++/bind.h, sigc++/bind_return.h, - sigc++/class_slot.h.m4, sigc++/hide.h.m4, - sigc++/method_slot.h.m4, sigc++/object.h, - sigc++/object_slot.h.m4, sigc++/retype.h.m4, - sigc++/retype_return.h sigc++/slot.h.m4, - sigc++/compatibility.h: - New files to complete compatibility module. - Split content of compatibility.h.m4 among the new files. - * sigc++/compatibility.h.m4: Removed. - * Makefile.am: Build and distribute new files. - * tests/test_compatibility.cc: Test new stuff. - - Fixes: - * sigc++/functors/slot.h.m4: Fix copy constructor and - operator=() of slot template. - * sigc++/adaptors/bind.h.m4: Fix deduce_result_type - template specializations. bind<0>() probably compiles - with gcc-3.3, now. - -2003-10-26 Martin Schulze - - Fixes: - * sigc++/functors/slot.{cc,h.m4}: - - Fix notification process: don't defer detaching of a - slot from all referred trackables during signal emission! - - Size optimization: replace virtual functions from - struct typed_slot_rep with function pointers in slot_rep - (reduces size of a typical typed_slot_rep instantiation - by 30% !!!). - * tests/test_slot.cc: Test sigc::slot more thoroughly. - * sigc++/functors/mem_fun.h.m4: Fix visit_each(). - * sigc++/adaptos/bind_return.h.m4: Add support for - sigc::ref(). - * tests/test_bind_return.cc: Use sigc::ref(). - * sigc++/signal.h.m4: Avoid compiler warning about - uninitialized variable r_ in emit(). - * sigc++/visit_each.h: Cleanup. - - API additions: - * sigc++/adpators/lambda/operators.h.m4: Add - lambda actions sigc::{reinterpret,static,dynamic}_cast_ - to support explicit parameter conversion. - * tests/test_lambda.cc: Test sigc::static_cast_. - * sigc++/adaptors/retype_return.h.m4: New file adding - adaptor retype_return (and hide_return). - * sigc++/Makefile.am: Build and distribute new file. - * tests/test_retype_return.cc: New file testing - adaptor retype_return (and hide_return). - * tests/Makefile.am: Build and distribute new test case. - -2003-10-25 Martin Schulze - - * sigc++/visit_each.h: Remove disturbing - limit_derived_target<>::operator() overloads. - * sigc++/adaptors/bind.h.m4: Add support for sigc::ref(). - * tests/test_bind.cc: Test sigc::ref(). - * sigc++/adaptors/lambda/{operator,group,base}.h.m4: - - Move support for sigc::ref() from lambda_core<> into - lambda operator and lambda group creator functions. - - Add missing visit_each() overload for lambda<> template. - * tests/test_lambda.cc: Test auto-disconnection. - TODO: Fix a strange bug that leads to "Bus error" - during auto-disconnection. - -1.9.10: - -2003-10-23 Martin Schulze - - * configure.ac: Bump version number to 1.9.10. - * NEWS: Add ChangeLog summary for version 1.9.10. - -2003-10-23 Martin Schulze - - * sigc++/functors/{functor_trait,slot}.h.m4: - Move definition of struct nil into functor_trait.h. - -2003-10-23 Martin Schulze - - * configure.ac: Disable typeof() compiler checks. - * sigc++/adaptors/bind.h.m4: Remove unnecessary - deduce_result_type<> template specializations. - -2003-10-20 Martin Schulze - - * sigc++/adaptors/compose.h.m4: - Correct order of typedefs for good. (Patch from Jeff Franks.) - -1.9.9: - -2003-10-20 Martin Schulze - - * sigc++/connection.h: Add constructor that takes - a sigc::slot_base& to support 3rd-party slot lists - like they are used in glibmm/gtkmm. - * sigc++/functors/slot.h.m4: Make sigc::slot::call_type public. - (Fixes compile problems reported by Jeff Franks.) - * sig++/type_traits.h: Don't use long long in - sigc::is_base_and_derived. - (Fixes compile problems reported by Jeff Franks.) - * sigc++/adaptors/{bind,compose,hide,exception_catch}.h.m4: - Correct order of typedefs. (Repoted by Jeff Franks.) - * configure.ac: Bump version number to 1.9.9. - * NEWS: Add ChangeLog summary for version 1.9.9. - -1.9.8: - -2003-10-19 Martin Schulze - - * sigc++/functors/slot.h.m4: Define doxygen group functors. - * configure.ac: Bump version number to 1.9.8. - * NEWS: Add ChangeLog summary for version 1.9.8. - -2003-10-19 Martin Schulze - - * NEWS: Add announces of versions 1.9.6 and 1.9.7. - * sigc++/compatibility.h.m4: New file. Defines namespace SigC. - namespace SigC should be API compatible to libsigc++-1.2. - * sigc++/Makefile.am: Build compatibility.h. - * tests/test_compatibility.cc, tests/Makefile.am: - Add test case for compatibility module. - * docs/index.html: Change group names. - * sigc++/sigc++.h: Include connection.h. - * sigc++/connection.{cc,h}: - - Rename dependency to destroy_notify_callback. - - Change parameter name in set_slot() from d to data. - - Fix operator=(): Add "return *this;" - - Get rid of namespace functor. - - Corrections in documentation. - * sigc++/signal.{cc,h.m4}: - - Add reference counter to signal_impl. Replaces "bool destroy_". - - Move signal_base, slot_iterator[_buf], slot_list out of - namespace internal. They are part of the public API. - - Add convenience function signal#::make_slot(). - - Get rid of namespace functor. - - Corrections in documentation. - * sigc++/trackable.{cc,h}: - - Rename dependency to destroy_notify_callback. - - Rename trackable::clear() to trackable::notify_callbacks(). - - Corrections in documentation. - * sigc++/type_traits.h: Add documentation. - * sigc++/visit_each.h: - - Get rid of namespace functor. - - Add documentation. - * sigc++/adaptors[/lambda]/*: Get rid of namespace functor. - * sigc++/functors/{functor_trait.h,ptr_fun.h.m4,mem_fun.h.m4}: - - Get rid of namespace functor. - - Corrections in documentation / add documentation. - * sigc++/functors/slot.{cc,h.m4}: - - Move slot_base out of namespace internal. It's public API. - - Get rid of one-letter-parameter-names. - - Get rid of namespace functor. - - Corrections in documentation. - * tests/*.cc: Get rid of "using namespace ...". - -2003-09-10 Martin Schulze - - * sigc++/adaptors/lambda/{base,operators}.h.m4: - Add subscript ([]) and assign (=) operator. I think there are now - enough operators available to make any future power user happy. - The only one missing is the comma operator and if we added it - the logical consequence would be to also add if(), switch(), do(), - etc. lambda expressions which are really out of place in libsigc++. - * sigc++/type_traits.h: Fix is_base_and_derived<> for const types. - * tests/test_lambda.cc: Test new operators. - -1.9.7: - -2003-09-05 Martin Schulze - - * configure.ac: Bump version number to 1.9.7. - -2003-09-03 Martin Schulze - - * sigc++/adaptors/lambda/operator.h.m4: - - Restructure so that the size of the generated source file stays - reasonable for 34 operators: There are only two lambda templates - lambda_operator and lambda_operator_unary. The action is an additional - template parameter. A small template lambda_action[_unary] is specialized - for all actions. - - Add most operators that boost::lambda supports. Missing operators are - "=", "[]", "," and support for pointer arithmetic. I don't know if it's - worth adding these. In libsigc++, the purpose of lambda operators is to - provide some extra functionality for the group adaptor. - * tests/test_lambda.cc: - Test pre-increment, address and dereference operator. - -2003-08-31 Martin Schulze - - * sigc++/reference_wrapper.h, sigc++/type_traits.h, sigc++/Makefile.am: - New file reference_wrapper.h provides ref() to specify that adaptors/lambdas - should take a reference to the object passed into ref() instead of a copy. - * tests/test_lambda.cc: - - Test group() with mem_fun(). - - Use ref() where lambdas should store references to objects. - - Test var() and constant(). - * sigc++/adaptors/lambda/base.h.m4: - - Support ref() in return type deduction. - - Add var() and constant() which create lambdas for usage with lambda operators. - * sigc++/adaptors/lambda/operator.h.m4: - - Fix return type deduction. - - Remove operator{+,-,*,...} overloads added on 2003-08-29. ref() is way cleaner. - * sigc++/adaptors/lambda/group.h.m4, - sigc++/adaptors/bind.h.m4, sigc++/adaptors/compose.h.m4, - sigc++/adaptors/exception_catch.h.m4, sigc++/adaptors/hide.h.m4: - Fix return type deduction. - -2003-08-29 Martin Schulze - - * tests/test_lambda.cc: Add more tests. - * sigc++/adaptors/lambda/select.h.m4, sigc++/adaptors/lambda/lambda.cc.m4: - Make _1, _2, ... constant. - * sigc++/adaptors/lambda/operator.h.m4: - Add operator{+,-,*,...} overloads to distinguish between const and non-const objects. - Store references to non-const objects rather than copies. - This allows expressions like e.g. std::cout << _1. - * sigc++/adaptors/lambda/base.h.m4, sigc++/adaptors/lambda/group.h.m4: - Remove void specializations. Functors returning void are tested and work fine. - -2003-08-27 Martin Schulze - - * tests/test_callof.cc, tests/test_deduce_result_type.cc: - Rename, correct and improve this test case. - * tests/Makefile.am: Build and run test_deduce_result_type - instead of test_callof. - -2003-08-27 Martin Schulze - - * Update TODO. - -2003-08-27 Martin Schulze - - * sigc++/adaptors/hide.h.m4: Remove usage of callof_ignore_arg<>. - * sigc++/callof.h.m4, sigc++/adaptors/deduce_result_type.h.m4, - sigc++/functors/functor_trait.h.m4: - Remove the first and move deduce_result_type templates from - functor_trait.h.m4 into new file deduce_result_type.h.m4. - * sigc++/Makefile.am, sigc++/sigc++.h, sigc++/adaptors/adaptor_trait.h.m4: - Build and include sigc++/adaptors/deduce_result_type.h instead of callof.h. - * sigc++/functors/slot.h.m4: Document struct nil. - -2003-08-24 Martin Schulze - - * sigc++/functors/functor_trait.h.m4: Simplify usage of convenience - macro SIGC_FUNCTORS_HAVE_RESULT_TYPE: - namespace sigc{ namespace functor{ SIGC_FUNCTORS_HAVE_RESULT_TYPE }} - -2003-08-24 Martin Schulze - - * sigc++/functors/functor_trait.h,m4, sigc++/adaptors[/lambda]/*.h.m4: - Merge adaptor return type deduction and typeof() into - sigc::functor::deduce_result_type. Use it for all adaptors. - * tests/test_compose.cc: Only test multi-type get-functor if - typeof() if supported. - -2003-08-24 Martin Schulze - - * sigc++/adaptors[/lambda]/*.h.m4: - - Remove unnecessary void specializations. In fact, only the one - for sigc::functor::exception_catch<> is needed and I don't really - understand why. For the lambda stuff the void specializatoins are - just commented out at the moment. - - Make typeof() optional. Surprisingly, I got the lambda stuff working - without typeof()! The test suite doesn't catch all cases yet, so maybe - some thing are still not working. - TODO: Implement configure check. - * tests/test_bind.cc, tests/test_compose.cc tests/test_exception_catch.cc, - tests/test_hide.cc, tests/test_lambda.cc: - Only test multiple functor return types if typeof() is supported. - -2003-08-06 Martin Schulze - - * sigc++/trackable.{cc,h}: Add function trackable::clear(). - -2003-06-24 Andreas Rottmann - - * TODO: Minor tweaks. - -2003-06-23 Andreas Rottmann - - * docs/reference/Doxyfile.in: Use these variables. - * docs/reference/Makefile.am (html/index.html): Provide doxygen - with SRCDIR and TOP_SRCDIR environment variables. - - * sigc++/functors/slot.h.m4: Make slot::call_type typedef public; - this fixes a g++ 3.3 error in signal.h. - - * sigc++/signal.h.m4: Make the signal::accumulated class public; - this fixes a g++ 3.3 error in test_accumulated.cc. - -2003-06-15 Martin Schulze - - * sigc++/functor/slot.h.m4: Correct typing error in docs. - * sigc++/functor/ptr_fun.h.m4: Document the whole thing. - -2003-05-31 Murray Cumming - - * Reference documentation: Rearranged the groups to make it all - a bit more like the libsigc++ 1.2 reference documentation. - Corrected some spelling and grammar too. - This needs a lot of work. The text is very hard to read and it's - generally not appropriate for a user of the code who doesn't - care about the internals. But it's not impossible - our examples - should show us what we need to say in the documentation. - We probably need some more groups for the extra stuff, like we do - in libsigc++ 1.2. - -2003-05-29 Martin Schulze - - * sigc++/signal.h.m4: Fix documentation. - * sigc++/connection.h, sigc++/functor/slot.h.m4: - Document the whole thing. - -2003-05-29 Martin Schulze - - * sigc++/signal.h.m4: - - Remove bogus operator() from unnumbered signal<> and - signal<>::accumulated templates. - - Document the whole thing. - - * docs/index.html: Fix some links. - -2003-04-06 Martin Schulze - - * TODO, configure.ac, Makefile.am, docs/*: - Add Doxygen framework. - -2003-04-06 Martin Schulze - - * sigc++/callof.h.m4, sigc++/adaptors/*, tests/test_callof.cc: - Move sigc::callof<> to sigc::functor::internal::callof<>. - - * sigc++/functors/mem_fun.h.m4, tests/test_mem_fun.cc: - Add new types [bound_][const_]volatile_mem_functor, visit_each() - and mem_fun() overloads for volatile qualifier. - Add ctor overloads in bound_*mem_functor and mem_fun() overloads - that take reference instead of pointer. - -2003-03-26 Martin Schulze - - * Change "closure" to "slot" throughout sigc++2 (file names, - class names, member variables, documentation, etc.). - -2003-03-26 Martin Schulze - - * TODO: Rewrite to reflect recent changes as well as recent discussions. - -2003-03-24 Martin Schulze - - * sigc++/adaptors/bind_return.h.m4: Make the adaptor's data member - public so that visit_each() can access it. - - * sigc++/adaptors/lambda/*.h.m4: More fixes. Add a note about - malfunctioning typeof() (probably compiler bug in gcc-3.2). - - * tests/*.cc: Test references. Fix compose equivalent in test_lambda. - -2003-03-24 Martin Schulze - - * sigc++/Makefile.am, sigc++/functors/functor_trait.h[.m4], - sigc++/adaptors/adaptor_trait.h.m4: Move detection of function - and member method pointers' return types from adaptor_trait into - functor_trait. (We'll use functor_trait rather than adaptor_trait for - our lambda stuff.) functor_trait.h needs to be generated from .m4 now. - - * sigc++/functors/functor_trait.h.m4: Add convenience macros: - - SIGC_FUNCTORS_HAVE_RESULT_TYPE indicates that the existance of - T_functor::result_type should be assumed for all unknown functors. - - SIGC_FUNCTOR_TRAIT(T_functor, T_result) explicitly specifies the - result type of a functor. - ("typename functor_trait::result_type") is used to - determine the return type of our adaptors' operator()() overloads. - - * sigc++/adaptors/[lambda/]*.h.m4: Various fixes in visit_each() and - operator()() overloads to make these operator()() overloads usable. - Most of them were just commented out before. Some adaptor types also - have void specializations, now. - - * sigc++/adaptors/lambda/group.h.m4: Change syntax from - "[some_functor] % grp([args])" to "group([some_functor], [args])" - like we agreed on the ml some time ago. - - * sigc++/tests/test_[all adaptors].cc: Test stuff that didn't work - before. - -2003-03-22 Murray Cumming - - * Added pgk-config file, from a mystery person in bug #108857 - -2003-03-22 Martin Schulze - - * tests/test_bind.cc: Test and show how to use functor_trait - for user defined or 3rd-party functors so that a - bind<0>([functor],[arg1])() call with no arguments can return a value. - -2003-03-20 Martin Schulze - - * sigc++/callof.h.m4: Add explanations. Comment in / create templates - callof_safe[#]. Unfortunately they don't work for functors with overloaded - operator() so we don't use it for now. At least everything is documented. - - * sigc++/functors/functor_trait.h, sigc++/functors/*.h.m4: Add back - functor_base compiler hint. We're using it now in adaptor_functor<>. - - * sigc++/adaptors/{adaptor_trait,bind}.h.m4: Make operator() overloads - with no arguments return the result of the functor invocation. - Fix multiple bind<0>(). - * tests/test_bind.cc: Test the stuff that's working now. - -2003-03-16 Murray Cumming - - * Added sigc++/sigc++.h, like in libsigc++ 1.2 - * examples: Added member_method example, which uses a class method - and which demonstrates disconnection. - -1.9.6: - -2003-03-11 Andreas Rottmann - - * sigc++/Makefile.am: Use substitution references instead of - $(patsubst). Is shorter and fixes the strange-dirs-in-dist-tarball - bug. - -2003-03-09 Martin Schulze - - * sigc++/connection.h: Add block() capability. - -2003-03-09 Martin Schulze - - * sigc++/signal.{cc,h.m4}: Add flag signal_impl::destroy_ - and function signal_impl::destroy(). Use them to defer - the destruction of the signal_impl object during signal - emission. - - * tests/test_disconnect.cc: Add tests for the connection - class and for deleting signals during emission. - -2003-03-09 Martin Schulze - - * sigc++/connection.{cc,h}, sigc++/Makefile.am: - - New files that add a connection class. Objects of this - class are constructed from closure list iterators and can - be used to disconnect the refered closure. As opposed to - iterators they stay valid beyond the lifetime of the closure. - -2003-03-09 Martin Schulze - - * sigc++/functors/closure.{cc,h.m4}, sigc++/signal.cc: - - Rename closure_{base,rep}::[set_]dependency_ -> [set_]parent_. - - Make closure_rep inherit trackable. This allows for - connection objects that stay valid beyond the life time - of the refered closure. - - Make some one-line-functions inline again. - -2003-03-08 Martin Schulze - - * sigc++/trackable.cc: BUGFIX in trackable_dep_list::clear() - -2003-03-08 Andreas Rottmann - - * sigc++/Makefile.am: Rewritten so we can build lambda cleanly. - * sigc++/Makefile.am_fragment: Removed. - - * sigc++/functors/Makfile.am: Removed. - * sigc++/adaptors/Makefile.am: Removed. - * sigc++/adaptors/lambda/Makefile.am: Removed. - * configure.ac (AC_OUTPUT): Remove the above Makefiles. - - * tests/Makefile.am: Re-included lambda test. - -2003-03-07 Martin Schulze - - * sigc++/signal.{cc,h.m4}: - - signal_emit#<>: New templates replacing signal#<>::caller. - The purpose of these templates is implementing the emit - function and optimizing signal emission for the case that - no accumulator is used via template specializations. - - default_accumulator<>: Removed. The default for T_accumulator - in signal#<> now is nil. An example how to use accumulators - is available in tests/test_accumulator.cc. - - signal_{base,impl}: Move the implementation of signal_base's - interface to signal_impl. An object of this class is - dynamically allocated when first connecting a closure to - the signal. This drastically reduces the size of empty signals - and allows for future addition of a reference counter to make - it safe to delete a signal during emission. - - Directly work on closure_rep during signal emission. This - seems to be quicker than using the closure templates. - - Document the classes. Restructure the header file a bit. - - * sigc++/functors/closure.h.m4: Make closure_base::rep_ data - member public, so that signal emission can directly work on it. - - * tests/test_size.cc: Add an entry for signal_impl. - -2003-03-07 Martin Schulze - - * sigc++/functors/closure.{cc,h.m4}: - - closure_base: BUGFIXES in ~closure_base() and operator=(). - - Mark some functions with the inline keyword. This seems to - help gcc 3.2 to optimize signal emission and (dis)connection. - - Document the classes. Restructure the header file a bit. - -2003-03-07 Martin Schulze - - * sigc++/trackable.{cc,h}: Make trackable allocate a - trackable_dep_list object dynamically when adding the first - dependency. (This reduces the size of objects, that are not - refered by a closure by 4 bytes (50%) and increases the size - of objects that are refered by a closure by 4 bytes (50%) - on a 32 bit architecture => This reduces total memory use - when >50% of the trackables are not refered by a closure.) - Document the classes. - -2003-03-05 Martin Schulze - - * tests/Makefile.am, tests/test_size.cc, tests/test_accumulated.cc: - Add two test cases. test_size is showing the size of public and - internal structures. (Which apart from empty signals are smaller - than the sizes of the equivalent libsigc++-1.2 structures.) - test_accumulated is a test for the template signal<>::accumulated<> - at the same time showing the use of accumulators in libsigc++2. - - * Offtopic: My note about binary sizes from 2003-02-10 is wrong. - Stripped libsigc++2 test binaries are about 8-10k in size. - -2003-03-05 Martin Schulze - - * sigc++/visit_each.h: BUGFIX in template specialization - limit_derive_target::with_type: - Add non-const overloads for static void execute_() avoiding - compile time errors. - -2003-02-16 Martin Schulze - - * tests/Makefile.am, tests/test_disconnect.cc: - Add testcase with a mixed connection & disconnection sequence. - -2003-02-16 Martin Schulze - - * sigc++/signal.cc: Bugfix in signal_base::insert(): - Set notification function in the newly created copy of - slot_ rather than in slot_ itself. - -2003-02-10 Martin Schulze - - * sigc++/signal.h.m4: Comment in typedefs for iterator types in - the signal#<> class template. Make signal#<>::connect() return an - iterator for convenience. - (Note that the first change increases the binary size of - tests/test_signal from 201k to 204k, the second change to 206k.) - -2003-01-23 Murray Cumming - - * sigc++/adaptors/lambda is disable temporarily (not built and - not distributed) because it gets built before its parent - directory, but #includes generated sources in the parent directory. - -2003-01-22 Murray Cumming - - * Added Andreas Rottman's example. - -2003-01-22 Murray Cumming - - * Applied Andreas Rottman's make dist fixes. - -2003-01-14 Murray Cumming - - * Added whitespace to make the code more readable. diff --git a/MSVC_NMake/MSVC-Builds.md b/MSVC_NMake/MSVC-Builds.md new file mode 100644 index 00000000..777bb5ea --- /dev/null +++ b/MSVC_NMake/MSVC-Builds.md @@ -0,0 +1,78 @@ +Instructions for building libsigc++ on Visual Studio += + +Building libsigc++ on Windows is now supported using Visual Studio +versions 2017 or later in both 32-bit and 64-bit (x64 and ARM64) flavors, +via NMake Makefiles, Meson or CMake. Due to `C++17` usage, Visual Studio 2015 or +earlier is not supported, and any use of the headers installed with +this package will require the use of the `/std:c++17` compiler flag. + +libsigc++ itself has no external dependencies, but building the +benchmark test program will require an installation of the Boost +C++ libraries. + +Building with NMake +- +The following describes what items are built with the following +targets: + +* `all`, `examples`: (or no target specified): The libsigc++ DLL and the example programs. +* `tests`: The libsigc++ DLL and the test programs. +* `benchmark`: The libsigc++ DLL and the benchmark program, the Boost C++ headers should be found in one of the paths that are in`%INCLUDE%`. + +Building directly from a GIT checkout is now supported, provided that a `PERL` +installation is present (pass the `PERL` interpreter executable in your NMake +command line by using `nmake /f Makefile.vc ... PERL=` by using +the `prep-git-build` target. + +The following are instructions for performing such a build. A `clean` target is +provided-it is recommended that one cleans the build and redo the build if any +configuration option changed. An `install` target is also provided to copy the built +items in their appropriate +locations under `$(PREFIX)`, which is described below. + +Invoke the build by issuing the command: +`nmake /f Makefile.vc CFG=[release|debug] [PREFIX=...] ` +where: + +* `CFG`: Required. Choose from a `release` or `debug` build. Note that + all builds generate a `.pdb` file for each `.dll` and `.exe` built. + +* `PREFIX`: Optional. Base directory of where the third-party headers, libraries +and needed tools can be found, i.e. headers in `$(PREFIX)\include`, +libraries in `$(PREFIX)\lib` and tools and DLLs in `$(PREFIX)\bin`. If not +specified, `$(PREFIX)` is set as `$(srcroot)\..\vs$(X)\$(platform)`, where +`$(platform)` is `win32` for 32-bit builds or `x64` for 64-bit (Intel/AMD) +builds or `arm64` for 64-bit (ARM) builds, and `$(X)` is the short version of the +Visual Studio used, as follows: + * 2017: `15` + * 2019: `16` + * 2022: `17` + +* `USE_COMPAT_LIBS`: Build the libsigc++ DLL and .lib with the filename +`sigc-vc150(d)-3_0` for all builds. This is for compatibility reasons, +if re-building dependent code is not convenient, for instance + +* Options, set by `
-
-
- -libsigc++ mailing list - | -website source - | - -*SOURCEFORGE* -  - - -
- - diff --git a/docs/website/fragments/html_declaration.html_fragment b/docs/website/fragments/html_declaration.html_fragment deleted file mode 100644 index bc2e4836..00000000 --- a/docs/website/fragments/html_declaration.html_fragment +++ /dev/null @@ -1,47 +0,0 @@ - - - - - libsigc++ -- The Typesafe Callback Framework for C++ - - - - - -
- -
- - Main
- - Features
- - License
-
- Documentation
- - Download
-
- Mailing List
- - Patches
- - Git
-
- Links
- -
- -
- -
- - - - - -
libsigc++ - Callback Framework for C++ -
- -
diff --git a/docs/website/glossary.shtml b/docs/website/glossary.shtml deleted file mode 100644 index 51e8540b..00000000 --- a/docs/website/glossary.shtml +++ /dev/null @@ -1,54 +0,0 @@ - - - - - -

Glossary of Terms

 - -

adaptor (noun) - A function which alters a slot’s -signature.

- -

bind (verb) - To fix a value of a callback's argument in the -STL sense.

- -

call (verb) - The process of invoking a callback or slot.

- -

callback (noun) - A function or a member function which will -be called when a signal is emitted. A slot specifies the callback and any extra -data, such as the object instance, and extra parameters.

- -

connect (verb) - The process of specifying the callback -which will be called when the signal is emitted.

- -

emit (verb) - When a signal is emitted, the connected slots -will be called.

- -

factory (noun) - A function which takes a set of arguments and -produces a different object based on those arguments.

- -

handle (noun) - A safe version of a pointer.

- -

marshaller (noun) - When a signal has a return value, and -several slots are connected to that signal, each one returning a value, then a -marshaller chooses one single return value.

- -

safe (adj) - Any structure which falls back into uninitalized state -when its related resources are destroyed. Safe resources can be -held throughout the program. Unsafe resources may point to freed -memory.

- -

signal (noun) - An object to which callback slots can be -connected. When the signal is emitted, each callback will be invoked. The -signal and the connected slots have a specific return type and parameter types. -

- -

signal handler (noun) - Another name for a callback.

- -

signature (noun) - The return type of a function together with -the argument types of that function.

- -

slot (noun) - A safe version of a callback.

- - - - diff --git a/docs/website/index.shtml b/docs/website/index.shtml deleted file mode 100644 index c8ca9d73..00000000 --- a/docs/website/index.shtml +++ /dev/null @@ -1,87 +0,0 @@ - - - - - -

About

 -

-libsigc++ implements a typesafe callback system for standard C++. It -allows you to define signals and to connect those signals to any -callback function, either global or a member function, regardless of -whether it is static or virtual. -

-

-It also contains adaptor classes for connection of dissimilar -callbacks and has an ease of use unmatched by other -C++ callback libraries. Libsigc++ is licensed under -the GNU Library General Public License, LGPL. -

-

-

Features

-
    -
  • Compile time typesafe callbacks (faster than run time checks)
    • -
  • Typesafety violations report line number correctly with - template names (no tracing template failures into headers)
    • -
  • No compiler extensions or meta compilers required
    • -
  • Proper handling of dynamic objects and signals - (deleted objects will not cause seg faults)
    • -
  • Extendable API at any level: - signal, slot, connection and trackable
    • -
  • Extensions do not require alteration of basic components
    • -
  • User definable accumulators
    • -
  • A variety of adaptors to change the callback signature: - bind, hide, retype, compose
    • -
  • Most C++ compilers can be used. libsigc++ version 2.5.1 and later require - a compiler with C++11 support
    • -
-

-

-

News

- -libsigc++ has reached the major version 2.0. -libsigc++ 2.0 has been rewritten from scratch adapting modern C++ coding techniques that -allow for a flexible and powerful but yet simple-to-use API. - -In particular the API improvements from libsigc++ 1.2 to 2.0 include: -
    -
  • Provides unnumbered signal and slot templates.
    • -
  • Supports arbitrary functor types.
    • -
  • Supports implicit argument type conversions on signal emission.
    • -
  • Adds support for overloaded functions.
    • -
  • Borrows powerful accumulator interface from boost::signal.
    • -
  • Simplifies use of adaptors like sigc::hide(): argument types need - not be specified any more (except for sigc::retype_return()).
    • -
  • More powerful adaptors: position of arguments to hide or bind can - be chosen freely; up to 7 arguments can be bound at a time.
    • -
  • Adds two useful adaptors: sigc::compose(), sigc::exception_catch().
    • -
  • Performs only one indirect function call during slot invokation - regardless of the number of adaptors used; the direct function - calls involved are inline and can be optimized away by the compiler.
    • -
  • Conforms to the STL naming scheme: only uses small letters.
    • -
  • libsigc++ 2.0 until 2.4.x supported a sigc::group() adaptor and - lambda functions. This support is discontinued in later releases, because - lambdas are supported by standard C++11.
    • -
-

- -

-Also good to check out are the Erik Thiele and Andreas Rottmann sites which -include some interesting libsigc++ tools like cross-thread support. -

- -

-

Developers

-The original library was composed by Tero Pulkkinen for the -gtkmm system, a C++ wrapper for the Gtk+ widget set. The revised -library was written and mantained by Karl Nelson. Special thanks -to Esa Pulkkinen for development tips. -The 1.2 phase was maintained by Murray Cumming after Karl provided the initial 1.2 code. -A long 1.9 phase led to the major release 2.0 which was previously maintained by Martin Schulze -and is currently being maintained by Murray Cumming and Kjell Ahlstedt. -

- - - - diff --git a/docs/website/license.shtml b/docs/website/license.shtml deleted file mode 100644 index 788b4ba0..00000000 --- a/docs/website/license.shtml +++ /dev/null @@ -1,510 +0,0 @@ - - - - - - -

-Libsigc++ is licensed under the GNU Library General Public License -for all platforms. Our intent in licensing it in this way is to -provide it for use through shared libraries in all projects both -open and proprietary. Other GNU projects may of course integrate -and link in a static manner. The full body of the license is -provided for your inspection. -

- -

-This is the only license which grants you use of the software, so -if you do not agree to its terms, you may not use this software. -

- -

-

- -
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-		       Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
-                    675 Mass Ave, Cambridge, MA 02139, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the library GPL.  It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-			    Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it.  You can use it for
-your libraries, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if
-you distribute copies of the library, or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library.  If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software.  To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
-  Most GNU software, including some libraries, is covered by the ordinary
-GNU General Public License, which was designed for utility programs.  This
-license, the GNU Library General Public License, applies to certain
-designated libraries.  This license is quite different from the ordinary
-one; be sure to read it in full, and don't assume that anything in it is
-the same as in the ordinary license.
-
-  The reason we have a separate public license for some libraries is that
-they blur the distinction we usually make between modifying or adding to a
-program and simply using it.  Linking a program with a library, without
-changing the library, is in some sense simply using the library, and is
-analogous to running a utility program or application program.  However, in
-a textual and legal sense, the linked executable is a combined work, a
-derivative of the original library, and the ordinary General Public License
-treats it as such.
-
-  Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries.  We
-concluded that weaker conditions might promote sharing better.
-
-  However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves.  This Library General Public License is intended to
-permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them.  (We have not seen how to achieve
-this as regards changes in header files, but we have achieved it as regards
-changes in the actual functions of the Library.)  The hope is that this
-will lead to faster development of free libraries.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, while the latter only
-works together with the library.
-
-  Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
-		  GNU LIBRARY GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library which
-contains a notice placed by the copyright holder or other authorized
-party saying it may be distributed under the terms of this Library
-General Public License (also called "this License").  Each licensee is
-addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-  
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also compile or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    c) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    d) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the source code distributed need not include anything that is normally
-distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Library General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-			    NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-		     END OF TERMS AND CONDITIONS
-
-     Appendix: How to Apply These Terms to Your New Libraries
-
-  If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change.  You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
-  To apply these terms, attach the following notices to the library.  It is
-safest to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least the
-"copyright" line and a pointer to where the full notice is found.
-
-    
-    Copyright (C)   
-
-    This library is free software; you can redistribute it and/or
-    modify it under the terms of the GNU Library General Public
-    License as published by the Free Software Foundation; either
-    version 2 of the License, or (at your option) any later version.
-
-    This library 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
-    Library General Public License for more details.
-
-    You should have received a copy of the GNU Library General Public
-    License along with this library; if not, write to the Free
-    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the
-  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
-  , 1 April 1990
-  Ty Coon, President of Vice
-
-That's all there is to it!
-
-
- - - diff --git a/docs/website/link.shtml b/docs/website/link.shtml deleted file mode 100644 index 20bab8d0..00000000 --- a/docs/website/link.shtml +++ /dev/null @@ -1,46 +0,0 @@ - - - - -

GNOME Links

 - -

-Libsigc++ is part of the greater GNOME code base. -

-

- -

Callback Links

 - -

-There are a number of other C++ callback systems -and publications on construction of callback systems. -

-

- -

Users

 - -

-Here is a list of some of the projects that use libsigc++. -(Have a project which is using libsigc++? Mail us.) -

-

- - - - diff --git a/docs/website/stable.shtml b/docs/website/stable.shtml deleted file mode 100644 index 3c548f7c..00000000 --- a/docs/website/stable.shtml +++ /dev/null @@ -1,30 +0,0 @@ - - - - -

Download

 - -

Source Packages

 - -

-The source packages for libsigc++ are available on the GNOME ftp site -and via the GNOME download site. -

- -

Binary Packages

 - -

Whenever possible, you should use the official binary packages approved by the supplier of your operating system, such as your Linux distribution. -For instance, Ubuntu Linux, Debian Linux and Fedora Linux have official libsigc++ packages.

- -

Requirements

 - -pkg-config should be used to build software that depends on libsigc++. - -

-libsigc++ is built and tested for a standards-compliant C++ compiler. Luckily, the recent versions of all major C++ compilers are now sufficiently standards-compliant. -libsigc++ version 2.5.1 and later require a C++11-compliant compiler. -

- - - - diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt new file mode 100644 index 00000000..82659938 --- /dev/null +++ b/examples/CMakeLists.txt @@ -0,0 +1,23 @@ +# Copyright 2016, The libsigc++ Development Team +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library 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 +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, see . + +function (add_sigcpp_example EXAMPLE_SOURCE_FILE) + get_filename_component (example_name ${EXAMPLE_SOURCE_FILE} NAME_WE) + add_executable (${example_name} ${EXAMPLE_SOURCE_FILE}) + target_link_libraries (${example_name} sigc-${SIGCXX_API_VERSION}) +endfunction (add_sigcpp_example) + +add_sigcpp_example (hello_world.cc) +add_sigcpp_example (member_method.cc) diff --git a/examples/Makefile.am b/examples/Makefile.am index b77cc24c..3df0fd1c 100644 --- a/examples/Makefile.am +++ b/examples/Makefile.am @@ -16,10 +16,12 @@ ## along with this library. If not, see . AM_CPPFLAGS = -I$(top_builddir) -I$(top_srcdir) -AM_CXXFLAGS = $(SIGC_WXXFLAGS) +AM_CXXFLAGS = $(SIGC_WXXFLAGS) -DSIGCXX_DISABLE_DEPRECATED LDADD = $(top_builddir)/sigc++/libsigc-$(SIGCXX_API_VERSION).la noinst_PROGRAMS = hello_world member_method +dist_noinst_DATA = CMakeLists.txt + hello_world_SOURCES = hello_world.cc member_method_SOURCES = member_method.cc diff --git a/examples/hello_world.cc b/examples/hello_world.cc index aff82f2c..6a171abf 100644 --- a/examples/hello_world.cc +++ b/examples/hello_world.cc @@ -1,4 +1,4 @@ -/* Copyright 2003, The libsigc++ Development Team +/* Copyright 2003 - 2016, The libsigc++ Development Team * * Assigned to the public domain. Use as you wish without * restriction. @@ -9,17 +9,19 @@ #include -void on_print(const std::string& str) +void +on_print(const std::string& str) { std::cout << str; } -int main() +int +main() { - sigc::signal signal_print; - - signal_print.connect( sigc::ptr_fun(&on_print) ); - + sigc::signal signal_print; + + signal_print.connect(sigc::ptr_fun(&on_print)); + signal_print.emit("hello world\n"); return 0; diff --git a/examples/member_method.cc b/examples/member_method.cc index 574b1fc8..5fc5b2cf 100644 --- a/examples/member_method.cc +++ b/examples/member_method.cc @@ -1,4 +1,4 @@ -/* Copyright 2003, The libsigc++ Development Team +/* Copyright 2003 - 2016, The libsigc++ Development Team * * Assigned to the public domain. Use as you wish without * restriction. @@ -15,32 +15,32 @@ class Something : public sigc::trackable Something(); protected: + void on_print(int a); - virtual void on_print(int a); - - typedef sigc::signal type_signal_print; + using type_signal_print = sigc::signal; type_signal_print signal_print; - }; Something::Something() { - auto iter = signal_print.connect( sigc::mem_fun(this, &Something::on_print) ); + auto connection = signal_print.connect(sigc::mem_fun(*this, &Something::on_print)); signal_print.emit(2); - //This isn't necessary - it's just to demonstrate how to disconnect: - iter->disconnect(); - signal_print.emit(3); //Prove that it is no longer connected. + // This isn't necessary - it's just to demonstrate how to disconnect: + connection.disconnect(); + signal_print.emit(3); // Prove that it is no longer connected. } -void Something::on_print(int a) +void +Something::on_print(int a) { - std::cout << "on_print recieved: " << a << std::endl; + std::cout << "on_print received: " << a << std::endl; } -int main() +int +main() { - Something something; + Something something; return 0; } diff --git a/examples/meson.build b/examples/meson.build new file mode 100644 index 00000000..0ddf68ef --- /dev/null +++ b/examples/meson.build @@ -0,0 +1,29 @@ +# examples + +# input: sigcxx_own_dep, build_examples + +examples = [ +# [[dir-name], exe-name, [sources]] + [[], 'hello_world', ['hello_world.cc']], + [[], 'member_method', ['member_method.cc']], +] + +foreach ex : examples + dir = '' + foreach dir_part : ex[0] + dir = dir / dir_part + endforeach + ex_name = (dir / ex[1]).underscorify() + ex_sources = [] + foreach src : ex[2] + ex_sources += dir / src + endforeach + + exe_file = executable(ex_name, ex_sources, + cpp_args: '-DSIGCXX_DISABLE_DEPRECATED=1', + dependencies: sigcxx_own_dep, + implicit_include_directories: false, + build_by_default: build_examples, + install: false, + ) +endforeach diff --git a/examples/qt_with_qmake/README.md b/examples/qt_with_qmake/README.md new file mode 100644 index 00000000..e19ccf61 --- /dev/null +++ b/examples/qt_with_qmake/README.md @@ -0,0 +1,67 @@ +# libsigc++ with Qt + +It is possible to use libsigc++ with Qt. However, because of the signals/slots +mechanism of Qt, there is some setup that must be done in order for this to +happen correctly. + +The official Qt documentation may be found here: https://doc.qt.io/qt-5/signalsandslots.html#using-qt-with-3rd-party-signals-and-slots + +Steps to use libsigc++ with Qt: +1. In your .pro file, add `CONFIG += no_keywords`. This configures Qt to not +define the macros `emit`, `signals`, and `slot`. These are keywords for moc, +which preprocesses the source files in order to use Qt signals/slots. +2. In your header files, change the `signals:` section of your class to instead +be `Q_SIGNALS` +3. In your header files, change the `public slots:` section of your class to +instead be `public Q_SLOTS:` +4. In any class that you emit a signal, change `emit` to be `Q_EMIT`. + +In general, using the Q\_ macros is a good idea if your code is a library +intended to be used by people other than yourself, as they may be using +code(e.g. libsigc++/boost signals) that will conflict with Qt(moc) keywords. + +Here's an example of a class before and after this conversion(note: irrelevant +code has been removed): + +``` +class ExampleClass : public QObject { +signals: + void exampleSignal(); +public slots: + void example_slot(){ + emit exampleSignal(); + } +}; +``` + +After conversion: +``` +class ExampleClass : public QObject { +Q_SIGNALS: + void exampleSignal(); +public Q_SLOTS: + void example_slot(){ + Q_EMIT exampleSignal(); + } +}; +``` + +## Qt Slots Notes +Since libsigc++ simply requires a slot to be a function, you can call Qt +slots easily using libsigc++. Similarly, a function that is a libsigc++ slot +can also be used as a Qt slot. + +# Other Build Systems +If you are not using qmake to build your Qt project, you must tell your +buildsystem to define `QT_NO_KEYWORDS`. If you're using CMake, this may +be done like the following: + +``` +add_definitions(-DQT_NO_KEYWORDS) +``` + +or in a more modern CMake way: + +``` +target_compile_definitions(some_target PRIVATE QT_NO_KEYWORDS) +``` diff --git a/examples/qt_with_qmake/exampleclass.cpp b/examples/qt_with_qmake/exampleclass.cpp new file mode 100644 index 00000000..2d178b49 --- /dev/null +++ b/examples/qt_with_qmake/exampleclass.cpp @@ -0,0 +1,34 @@ +#include + +#include "exampleclass.h" + +ExampleClass::ExampleClass(QObject *parent) : + QObject(parent) +{ + /* Create a slot from our example_slot method. */ + m_sigc_slot = sigc::mem_fun( *this, &ExampleClass::example_slot ); + + /* Connect our sigc++ signal to our sigc++ slot */ + m_sigc_signal.connect( m_sigc_slot ); + + /* Emit a sigc++ signal */ + m_sigc_signal.emit(); + + /* Connect the Qt signal to our Qt slot */ + connect( &m_timer, &QTimer::timeout, + this, &ExampleClass::timer_slot ); + m_timer.start( 200 ); + + /* Emit a Qt signal */ + Q_EMIT example_signal(); +} + +void ExampleClass::timer_slot(){ + qDebug() << "Timer slot called"; + + QCoreApplication::exit( 0 ); +} + +void ExampleClass::example_slot(){ + qDebug() << "Example slot called"; +} diff --git a/examples/qt_with_qmake/exampleclass.h b/examples/qt_with_qmake/exampleclass.h new file mode 100644 index 00000000..7c8c5a76 --- /dev/null +++ b/examples/qt_with_qmake/exampleclass.h @@ -0,0 +1,36 @@ +#ifndef EXAMPLECLASS_H +#define EXAMPLECLASS_H + +#include +#include +#include + +#include + +class ExampleClass : public QObject +{ + Q_OBJECT +public: + explicit ExampleClass(QObject* parent = nullptr); + + /* Instead of using the keyword 'signals', use the 'Q_SIGNALS' macro */ +Q_SIGNALS: + void example_signal(); + + /* Instead of using the keyword 'slots', use the 'Q_SLOTS' macro */ +public Q_SLOTS: + void timer_slot(); + + /** + * This slot is called using libsigc++, however since it is defined under Q_SLOTS + * it could also be used with the Qt signals/slots + */ + void example_slot(); + +private: + sigc::slot m_sigc_slot; + sigc::signal m_sigc_signal; + QTimer m_timer; +}; + +#endif // EXAMPLECLASS_H diff --git a/examples/qt_with_qmake/main.cpp b/examples/qt_with_qmake/main.cpp new file mode 100644 index 00000000..c7dd7825 --- /dev/null +++ b/examples/qt_with_qmake/main.cpp @@ -0,0 +1,13 @@ +#include +#include + +#include "exampleclass.h" + +int main(int argc, char *argv[]) +{ + QCoreApplication a(argc, argv); + + ExampleClass ex; + + return a.exec(); +} diff --git a/examples/qt_with_qmake/qt-sigcpp.pro b/examples/qt_with_qmake/qt-sigcpp.pro new file mode 100644 index 00000000..154ab8f0 --- /dev/null +++ b/examples/qt_with_qmake/qt-sigcpp.pro @@ -0,0 +1,39 @@ +QT -= gui + +CONFIG += console +CONFIG -= app_bundle + +# Qt 5.12 introduces the 'c++17' config option; this sets it manually +QMAKE_CXXFLAGS += -std=c++17 + +# Since Qt #defines emit, signal, and slot, we need to disable those keywords +CONFIG += no_keywords + +# We must link with sigc++-3.0 +unix{ + CONFIG += link_pkgconfig + PKGCONFIG += sigc++-3.0 +} + +# The following define makes your compiler emit warnings if you use +# any Qt feature that has been marked deprecated (the exact warnings +# depend on your compiler). Please consult the documentation of the +# deprecated API in order to know how to port your code away from it. +DEFINES += QT_DEPRECATED_WARNINGS + +# You can also make your code fail to compile if it uses deprecated APIs. +# In order to do so, uncomment the following line. +# You can also select to disable deprecated APIs only up to a certain version of Qt. +#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000 # disables all the APIs deprecated before Qt 6.0.0 + +SOURCES += \ + main.cpp \ + exampleclass.cpp + +# Default rules for deployment. +qnx: target.path = /tmp/$${TARGET}/bin +else: unix:!android: target.path = /opt/$${TARGET}/bin +!isEmpty(target.path): INSTALLS += target + +HEADERS += \ + exampleclass.h diff --git a/libsigc++2.doap b/libsigcplusplus.doap similarity index 55% rename from libsigc++2.doap rename to libsigcplusplus.doap index ac695d2c..04b52680 100644 --- a/libsigc++2.doap +++ b/libsigcplusplus.doap @@ -1,23 +1,30 @@ + + libsigc++ Typesafe callback framework for C++ - libsigc++ implements a typesafe callback system for standard C++. + +libsigc++ implements a typesafe callback system for standard C++. It allows you to define signals and to connect those signals to any callback function, either global or a member function, regardless of whether it is static or virtual. -libsigc++ is used by glibmm and gtkmm to wrap Glib and GTK+ signals. - - - +libsigc++ is also used by glibmm and gtkmm to wrap GLib and GTK signals. + + + + + + C++ - @@ -29,7 +36,7 @@ libsigc++ is used by glibmm and gtkmm to wrap Glib and GTK+ signals. Kjell Ahlstedt - + kjellahl diff --git a/meson.build b/meson.build new file mode 100644 index 00000000..4d60b1b4 --- /dev/null +++ b/meson.build @@ -0,0 +1,370 @@ +# This file is part of libsigc++. + +project('libsigc++', 'cpp', + version: '3.6.0', + license: 'LGPLv2.1+', + default_options: [ + 'cpp_std=c++17', + 'warning_level=1', + ], + meson_version: '>= 0.62.0', # required for variables in pkgconfig.generate() +) + +sigcxx_api_version = '3.0' +sigcxx_pcname = 'sigc++-' + sigcxx_api_version + +sigcxx_version_array = meson.project_version().split('.') +sigcxx_major_version = sigcxx_version_array[0].to_int() +sigcxx_minor_version = sigcxx_version_array[1].to_int() +sigcxx_micro_version = sigcxx_version_array[2].to_int() + +# http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html +# The relation between libtool's current:revison:age interface versioning +# and the .so filename, .so.x.y.z, is +# x = current - age +# y = age +# z = revision +# If libtool_soversion is updated as described in libtool's documentation, +# x.y.z will usually *not* be equal to meson.project_version(). +libtool_soversion = [0, 0, 0] +sigcxx_libversion = '@0@.@1@.@2@'.format( + libtool_soversion[0] - libtool_soversion[2], + libtool_soversion[2], + libtool_soversion[1]) +darwin_versions = [libtool_soversion[0] + 1, '@0@.@1@'.format(libtool_soversion[0] + 1, libtool_soversion[1])] + +# Source and build root directories of the current (sub)project. +project_source_root = meson.project_source_root() +project_build_root = meson.project_build_root() + +cpp_compiler = meson.get_compiler('cpp') +cpp_compiler_id = cpp_compiler.get_id() +is_msvc_style = cpp_compiler.get_argument_syntax() == 'msvc' +python3 = find_program('python3', version: '>=3.7') + +# MSVC: We currently do not support shared and static builds at the same time, +# since we need different defines/cflags for proper linking. +if is_msvc_style + if get_option('default_library') == 'both' + error('-Ddefault_library=both is currently not supported for Visual Studio') + endif + is_msvc_static = get_option('default_library') == 'static' +else + is_msvc_static = false +endif + +# Do we build from a git repository? +# Suppose we do if and only if the meson.build file is tracked by git. +cmd_py = ''' +import shutil, subprocess, sys +git_exe = shutil.which('git') +if not git_exe: + sys.exit(1) +cmd = [ git_exe, 'ls-files', '--error-unmatch', 'meson.build' ] +sys.exit(subprocess.run(cmd, cwd=sys.argv[1], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode) +''' +is_git_build = run_command( + python3, '-c', cmd_py, + project_source_root, + check: false, +).returncode() == 0 + +# Are we testing a dist tarball while it's being built? +# There ought to be a better way. https://github.com/mesonbuild/meson/issues/6866 +is_dist_check = project_source_root.contains('dist-unpack') and \ + project_build_root.contains('dist-build') + +# Options. +maintainer_mode_opt = get_option('maintainer-mode') +maintainer_mode = maintainer_mode_opt == 'true' or \ + (maintainer_mode_opt == 'if-git-build' and is_git_build) +if is_dist_check + message('Looks like a tarball is being tested. ' + \ + 'Option "dist-warnings" is used instead of "warnings".') + cpp_warnings = get_option('dist-warnings') +else + cpp_warnings = get_option('warnings') +endif +if get_option('warning_level') in ['0','1','2','3','4','5'] + warning_level = get_option('warning_level').to_int() +else + # For instance get_option('warning_level') == 'everything' + warning_level = 99 +endif +werror = get_option('werror') +build_deprecated_api = get_option('build-deprecated-api') +build_documentation_opt = get_option('build-documentation') +build_documentation = build_documentation_opt == 'true' or \ + (build_documentation_opt == 'if-maintainer-mode' and maintainer_mode) +build_examples = get_option('build-examples') +build_tests = get_option('build-tests') +do_benchmark = get_option('benchmark') + +# Installation directories are relative to {prefix}. +install_prefix = get_option('prefix') +install_includedir = get_option('includedir') +install_libdir = get_option('libdir') +install_datadir = get_option('datadir') +install_pkgconfigdir = install_libdir / 'pkgconfig' + +# Dependencies. +# sigcxx_build_dep: Dependencies when building the libsigc++ library. +# sigcxx_dep (created in sigc++/meson.build): +# Dependencies when using the libsigc++ library. +sigcxx_build_dep = [] # No dependencies + +benchmark_dep = dependency('boost', modules: ['system', 'timer'], + version: '>=1.20.0', required: do_benchmark) +can_benchmark = benchmark_dep.found() + +if is_msvc_style + # We must have Visual Studio 2017 15.7 or later... + mscver = cpp_compiler.get_define('_MSC_VER') + assert(mscver == '' or mscver.version_compare('>=1914'), + 'Visual Studio 2017 15.7 or later or compatible is required') +endif + +# Some dependencies are required only in maintainer mode and/or +# if documentation shall be built. +mm_common_get = find_program('mm-common-get', required: false) + +if maintainer_mode and not mm_common_get.found() + message('Maintainer mode requires the \'mm-common-get\' command. If it is not found,\n' + + 'use \'-Dmaintainer-mode=false\' or install the \'mm-common\' package, version 1.0.0 or higher.') + # If meson --wrap-mode != forcefallback, Meson falls back to the mm-common + # subproject only if mm-common-get is required. + mm_common_get = find_program('mm-common-get', required: true) +endif + +doxygen = find_program('doxygen', required: build_documentation) +dot = find_program('dot', required: false) # Used by Doxygen, if found +xsltproc = find_program('xsltproc', required: build_documentation) + +if build_documentation and not dot.found() + message('The \'dot\' command is not found.\n ' + \ + 'This will affect the look of the inheritance diagrams in the documentation.') +endif + +script_dir = project_source_root / 'untracked' / 'build_scripts' +doc_reference = script_dir / 'doc-reference.py' +dist_changelog = script_dir / 'dist-changelog.py' +dist_build_scripts = script_dir / 'dist-build-scripts.py' +tutorial_custom_cmd = project_source_root / 'tools' / 'tutorial-custom-cmd.py' + +if maintainer_mode + # Copy files to untracked/build_scripts and untracked/docs/docs. + run_command(mm_common_get, '--force', script_dir, + project_source_root / 'untracked' / 'docs' / 'docs', + check: true, + ) +elif not import('fs').is_file(doc_reference) + warning('Missing files in untracked/.\n ' + \ + 'Enable maintainer-mode if you want to build documentation or create a dist tarball.') +endif + +# Check if perl is required and available. +doc_perl_prop = run_command( + python3, doc_reference, 'get_script_property', + '', # MMDOCTOOLDIR is not used + 'requires_perl', + check: false, +) +if not (doc_perl_prop.returncode() == 0 and doc_perl_prop.stdout() == 'false') + # Perl is required, if documentation shall be built. + perl = find_program('perl', required: build_documentation) +endif + +# Set compiler warnings. +# Meson warns if any of the /W1, /W2, /W3, /W4, /Wall, -Wall, -Wextra, -Werror +# compiler options are added with add_project_arguments(). +# Avoid such warnings, when possible. +# See _warn_about_builtin_args() in meson/mesonbuild/interpreter/interpreter.py. +warning_flags = [] +if cpp_warnings == 'min' + if warning_level == 0 + warning_flags = is_msvc_style ? ['/W2'] : ['-Wall'] + endif +elif cpp_warnings == 'max' or cpp_warnings == 'fatal' + if warning_level < 3 + warning_flags = is_msvc_style ? ['/W4'] : ['-pedantic', '-Wall', '-Wextra'] + endif + if not is_msvc_style + warning_flags += '-Wsuggest-override -Wshadow -Wzero-as-null-pointer-constant -Wformat-security'.split() + endif + if cpp_warnings == 'fatal' and not werror + warning_flags += is_msvc_style ? ['/WX'] : ['-Werror'] + endif +endif + +warning_flags = cpp_compiler.get_supported_arguments(warning_flags) +add_project_arguments(warning_flags, language: 'cpp') + +# MSVC: Ignore warnings that aren't really harmful, but make those +# that should not be overlooked stand out. +static_cxxflag = '-DLIBSIGCXX_STATIC' +msvc_static_cxxflag = is_msvc_static ? static_cxxflag : '' +if is_msvc_style + disable_warnings_list = [ + '/EHsc', # avoid warnings caused by exception handling model used + ] + + # Turn off harmless warnings but make potentially dangerous ones glaring, + # distributed with GLib, if available + use_recommended_pragmas = cpp_compiler.get_supported_arguments('/FImsvc_recommended_pragmas.h') + if use_recommended_pragmas.length() > 0 + add_project_arguments(use_recommended_pragmas, language: 'cpp') + else + disable_warnings_list += '/wd4244' # 'conversion' conversion from + # 'type1' to 'type2', possible loss of data + endif + + if host_machine.cpu_family() == 'x86_64' or host_machine.cpu_family() == 'aarch64' + # 'var' : conversion from 'size_t' to 'type', possible loss of data (applies on 64-bit builds) + disable_warnings_list += '/wd4267' + endif + add_project_arguments( + cpp_compiler.get_supported_arguments(disable_warnings_list), + language: 'cpp' + ) + if is_msvc_static + add_project_arguments(static_cxxflag, language: 'cpp') + endif +endif + +# Configure files +pkg_conf_data = configuration_data() +pkg_conf_data.set('PACKAGE_VERSION', meson.project_version()) +pkg_conf_data.set('SIGCXX_API_VERSION', sigcxx_api_version) + +if not build_deprecated_api + pkg_conf_data.set('SIGCXX_DISABLE_DEPRECATED', 1) +endif +pkg_conf_data.set('SIGCXX_MAJOR_VERSION', sigcxx_major_version) +pkg_conf_data.set('SIGCXX_MINOR_VERSION', sigcxx_minor_version) +pkg_conf_data.set('SIGCXX_MICRO_VERSION', sigcxx_micro_version) + +sigcxxconfig_h_meson = files('sigc++config.h.meson') +install_includeconfigdir = install_libdir / sigcxx_pcname / 'include' +configure_file( + input: sigcxxconfig_h_meson, + output: 'sigc++config.h', + configuration: pkg_conf_data, + install: true, + install_dir: install_includeconfigdir, + install_tag: 'devel', +) + +#subdir('cmake') +subdir('MSVC_NMake') +subdir('sigc++') +subdir('examples') +subdir('tests') +subdir('docs/docs/reference') +subdir('docs/docs/manual') + +# Add a ChangeLog file to the distribution directory. +meson.add_dist_script( + python3, dist_changelog, + project_source_root, +) + +# Don't distribute these files and directories. +dont_distribute = [ + 'libsigcplusplus.doap', + '.github', +] +# Add build scripts to the distribution directory, and delete .gitignore +# files and an empty $MESON_PROJECT_DIST_ROOT/build/ directory. +meson.add_dist_script( + python3, dist_build_scripts, + project_source_root, + 'untracked' / 'build_scripts', + dont_distribute, +) + +if meson.is_subproject() + pkgconfig_vars = { + 'htmlrefdir': install_prefix / install_docdir / 'reference' / 'html', + 'htmlrefpub': 'https://libsigcplusplus.github.io/libsigcplusplus/reference/html/' + } + if build_documentation + pkgconfig_vars += {'doxytagfile': tag_file.full_path()} + # May be used in a main project. + global_tag_file_target = tag_file + endif + sigcxx_dep = declare_dependency( + dependencies: sigcxx_own_dep, + variables: pkgconfig_vars, + ) + + # A main project that looks for sigcxx_pcname.pc shall find sigcxx_dep. + meson.override_dependency(sigcxx_pcname, sigcxx_dep) +endif + +# Print a summary. +real_maintainer_mode = '' +if maintainer_mode_opt == 'if-git-build' + real_maintainer_mode = ' (@0@)'.format(maintainer_mode) +endif + +real_build_documentation = '' +if build_documentation_opt == 'if-maintainer-mode' + real_build_documentation = ' (@0@)'.format(build_documentation) +endif + +explain_man = '' +if build_manual_opt and not build_manual + explain_man = ' (requires that documentation is built)' +endif + +validate = get_option('validation') and can_parse_and_validate and build_manual +explain_val = '' +if get_option('validation') and not validate + if not build_manual + explain_val = ' (requires that the tutorial is built)' + else + explain_val = ' (requires xmllint with Relax NG and DocBook V5.0 support)' + endif +endif + +build_pdf = build_pdf_by_default and can_build_pdf and build_manual +explain_pdf = '' +if build_pdf_by_default and not build_pdf + if not build_manual + explain_pdf = ' (requires that the tutorial is built)' + else + explain_pdf = ' (requires dblatex or (xsltproc and fop))' + endif +endif + +summary = [ + '', + '------', + meson.project_name() + ' ' + meson.project_version(), + '', + ' Maintainer mode: @0@@1@'.format(maintainer_mode_opt, real_maintainer_mode), + ' Compiler warnings: @0@ (warning_level: @1@, werror: @2@)'. \ + format(cpp_warnings, warning_level, werror), + ' Build deprecated API: @0@'.format(build_deprecated_api), + 'Build HTML documentation: @0@@1@'.format(build_documentation_opt, real_build_documentation), + ' Build tutorial: @0@@1@'.format(build_manual, explain_man), + ' XML validation: @0@@1@'.format(validate, explain_val), + ' Build PDF: @0@@1@'.format(build_pdf, explain_pdf), + ' Build example programs: @0@'.format(build_examples), + ' Build test programs: @0@'.format(build_tests), + ' Benchmark: @0@'.format(do_benchmark), + 'Directories:', + ' prefix: @0@'.format(install_prefix), + ' includedir: @0@'.format(install_prefix / install_includedir), + ' includesigcxxdir: @0@'.format(install_prefix / install_includedir / sigcxx_pcname), + ' libdir: @0@'.format(install_prefix / install_libdir), + ' includeconfigdir: @0@'.format(install_prefix / install_includeconfigdir), + ' pkgconfigdir: @0@'.format(install_prefix / install_pkgconfigdir), + ' datadir: @0@'.format(install_prefix / install_datadir), + ' docdir: @0@'.format(install_prefix / install_docdir), + ' devhelpdir: @0@'.format(install_prefix / install_devhelpdir), + ' tutorialdir: @0@'.format(install_prefix / install_tutorialdir), + '------' +] + +message('\n'.join(summary)) diff --git a/meson_options.txt b/meson_options.txt new file mode 100644 index 00000000..0255a923 --- /dev/null +++ b/meson_options.txt @@ -0,0 +1,22 @@ +option('maintainer-mode', type: 'combo', choices: ['false', 'if-git-build', 'true'], + value: 'if-git-build', description: 'Let mm-common-get copy some files to untracked/') +option('warnings', type: 'combo', choices: ['no', 'min', 'max', 'fatal'], + value: 'min', description: 'Compiler warning level') +option('dist-warnings', type: 'combo', choices: ['no', 'min', 'max', 'fatal'], + value: 'fatal', description: 'Compiler warning level when a tarball is created') +option('build-deprecated-api', type: 'boolean', value: true, + description: 'Build deprecated API and include it in the library') +option('build-documentation', type: 'combo', choices: ['false', 'if-maintainer-mode', 'true'], + value: 'if-maintainer-mode', description: 'Build and install the documentation') +option('build-manual', type: 'boolean', value: true, + description: 'Build tutorial HTML files, if documentation is built') +option('validation', type: 'boolean', value: true, + description: 'Validate the tutorial XML file, if tutorial HTML files are built') +option('build-pdf', type: 'boolean', value: false, + description: 'Build tutorial PDF file, if tutorial HTML files are built') +option('build-examples', type: 'boolean', value: true, + description: 'Build example programs') +option('build-tests', type: 'boolean', value: true, + description: 'Build test programs') +option('benchmark', type: 'boolean', value: false, + description: 'Build and test benchmark program') diff --git a/sigc++-uninstalled.pc.in b/sigc++-uninstalled.pc.in index 9a9fde1a..89b2c26c 100644 --- a/sigc++-uninstalled.pc.in +++ b/sigc++-uninstalled.pc.in @@ -1,9 +1,9 @@ doxytagfile=${pc_top_builddir}/docs/reference/libsigc++-@SIGCXX_API_VERSION@.tag -htmlrefpub=http://library.gnome.org/devel/libsigc++/unstable/ +htmlrefpub=https://libsigcplusplus.github.io/libsigcplusplus/reference/html/ Name: libsigc++ Description: Typesafe signal and callback system for C++, not installed Version: @PACKAGE_VERSION@ -URL: http://libsigc.sourceforge.net/ +URL: https://libsigcplusplus.github.io/libsigcplusplus/ Libs: ${pc_top_builddir}/sigc++/libsigc-@SIGCXX_API_VERSION@.la Cflags: -I${pc_top_builddir} -I${pc_top_builddir}/@top_srcdir@ diff --git a/sigc++.pc.in b/sigc++.pc.in index c03a1ddc..e162f2fc 100644 --- a/sigc++.pc.in +++ b/sigc++.pc.in @@ -8,11 +8,11 @@ includedir=@includedir@ docdir=${datarootdir}/doc/libsigc++-@SIGCXX_API_VERSION@ doxytagfile=${docdir}/reference/libsigc++-@SIGCXX_API_VERSION@.tag htmlrefdir=${docdir}/reference/html -htmlrefpub=http://library.gnome.org/devel/libsigc++/unstable/ +htmlrefpub=https://libsigcplusplus.github.io/libsigcplusplus/reference/html/ Name: libsigc++ Description: Typesafe signal and callback system for C++ Version: @PACKAGE_VERSION@ -URL: http://libsigc.sourceforge.net/ +URL: https://libsigcplusplus.github.io/libsigcplusplus/ Libs: -L${libdir} -lsigc-@SIGCXX_API_VERSION@ -Cflags: -I${includedir}/sigc++-@SIGCXX_API_VERSION@ -I${libdir}/sigc++-@SIGCXX_API_VERSION@/include +Cflags: -I${includedir}/sigc++-@SIGCXX_API_VERSION@ -I${libdir}/sigc++-@SIGCXX_API_VERSION@/include @MSVC_STATIC_CXXFLAG@ diff --git a/sigc++/.gitignore b/sigc++/.gitignore deleted file mode 100644 index 5dc14d77..00000000 --- a/sigc++/.gitignore +++ /dev/null @@ -1,19 +0,0 @@ -/limit_reference.h -/signal.h -/adaptors/adaptor_trait.h -/adaptors/bind.h -/adaptors/bind_return.h -/adaptors/compose.h -/adaptors/deduce_result_type.h -/adaptors/exception_catch.h -/adaptors/hide.h -/adaptors/retype.h -/adaptors/retype_return.h -/adaptors/track_obj.h -/adaptors/lambda/base.h -/adaptors/lambda/lambda.cc -/adaptors/lambda/select.h -/functors/functor_trait.h -/functors/mem_fun.h -/functors/ptr_fun.h -/functors/slot.h diff --git a/sigc++/CMakeLists.txt b/sigc++/CMakeLists.txt new file mode 100644 index 00000000..d6945b2f --- /dev/null +++ b/sigc++/CMakeLists.txt @@ -0,0 +1,47 @@ +# Copyright 2016, The libsigc++ Development Team +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library 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 +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, see . + +set (SOURCE_FILES + connection.cc + scoped_connection.cc + signal_base.cc + trackable.cc + functors/slot_base.cc +) + +set (SIGCPP_LIB_NAME sigc-${SIGCXX_API_VERSION}) + +add_library(${SIGCPP_LIB_NAME} SHARED ${SOURCE_FILES}) + +set_property (TARGET ${SIGCPP_LIB_NAME} PROPERTY VERSION ${PACKAGE_VERSION}) +set_property(TARGET ${SIGCPP_LIB_NAME} PROPERTY SOVERSION ${LIBSIGCPP_SOVERSION}) +target_compile_definitions( ${SIGCPP_LIB_NAME} PRIVATE -DSIGC_BUILD ) + +set (INCLUDE_INSTALL_DIR "include/${PROJECT_NAME}-${SIGCXX_API_VERSION}") + +install ( + DIRECTORY "${PROJECT_SOURCE_DIR}" + DESTINATION "${INCLUDE_INSTALL_DIR}" + FILES_MATCHING PATTERN "*.h" +) + +set (PROJECT_CMAKE_NAME ${PROJECT_NAME}-3) + +install ( + TARGETS ${SIGCPP_LIB_NAME} + EXPORT "${PROJECT_CMAKE_NAME}Targets" + LIBRARY DESTINATION "lib" + INCLUDES DESTINATION "${INCLUDE_INSTALL_DIR}" +) diff --git a/sigc++/Makefile.am b/sigc++/Makefile.am index caa9e154..b8be4c27 100644 --- a/sigc++/Makefile.am +++ b/sigc++/Makefile.am @@ -20,23 +20,16 @@ AUTOMAKE_OPTIONS = subdir-objects include $(srcdir)/filelist.am # Subdirectories needed also in the build dir -build_subdirs = functors adaptors/lambda +build_subdirs = functors -dist_noinst_DATA = $(sigc_m4) +dist_noinst_DATA = CMakeLists.txt library_includedir = $(includedir)/$(SIGCXX_MODULE_NAME)/sigc++ nobase_library_include_HEADERS = sigc++.h $(sigc_public_h) $(sigc_built_h) lib_LTLIBRARIES = libsigc-@SIGCXX_API_VERSION@.la -libsigc_@SIGCXX_API_VERSION@_la_SOURCES = \ - signal.cc \ - signal_base.cc \ - trackable.cc \ - connection.cc \ - functors/slot.cc \ - functors/slot_base.cc \ - adaptors/lambda/lambda.cc +libsigc_@SIGCXX_API_VERSION@_la_SOURCES = $(sigc_sources_cc) EXTRA_libsigc_@SIGCXX_API_VERSION@_la_SOURCES = $(sigc_built_cc) @@ -49,8 +42,6 @@ AM_CXXFLAGS = $(SIGC_WXXFLAGS) BUILT_SOURCES = $(build_subdirs) $(sigc_built_h) $(sigc_built_cc) MAINTAINERCLEANFILES = $(sigc_built_h) $(sigc_built_cc) -m4_dir = $(srcdir)/macros - $(build_subdirs): $(AM_V_at)$(MKDIR_P) $@ @@ -62,22 +53,8 @@ signal.cc: \ functors/mem_fun.h \ functors/functor_trait.h -adaptors/lambda/lambda.cc: \ - adaptors/lambda/select.h \ - adaptors/lambda/base.h \ - adaptors/adaptor_trait.h \ - adaptors/deduce_result_type.h \ - functors/ptr_fun.h \ - functors/mem_fun.h \ - functors/functor_trait.h - functors/slot.cc: \ functors/slot.h \ functors/slot_base.h \ functors/functor_trait.h -%.h: macros/%.h.m4 $(m4_dir)/template.macros.m4 | $(build_subdirs) - $(AM_V_GEN)$(M4) -I $(m4_dir) -I macros $< >$@ - -%.cc: macros/%.cc.m4 $(m4_dir)/template.macros.m4 | $(build_subdirs) - $(AM_V_GEN)$(M4) -I $(m4_dir) -I macros $< >$@ diff --git a/sigc++/adaptors/adaptor_base.h b/sigc++/adaptors/adaptor_base.h new file mode 100644 index 00000000..4d8fa24d --- /dev/null +++ b/sigc++/adaptors/adaptor_base.h @@ -0,0 +1,40 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H +#define SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H + +namespace sigc +{ + +// TODO: Is this necessary now that we don't need deduce_result_type? +/** A hint to the compiler. + * Functors which have all methods based on templates + * should publicly inherit from this hint. + * + * Adaptors don't inherit from this type directly. They use + * use sigc::adapts as a base type instead. sigc::adaptors + * wraps arbitrary functor types as well as function pointers + * and class methods. + * + * @ingroup adaptors + */ +struct adaptor_base +{ +}; + +} /* namespace sigc */ +#endif /* SIGC_ADAPTORS_DEDUCE_RESULT_TYPE_H */ diff --git a/sigc++/adaptors/adaptor_trait.h b/sigc++/adaptors/adaptor_trait.h new file mode 100644 index 00000000..fbf8f6a0 --- /dev/null +++ b/sigc++/adaptors/adaptor_trait.h @@ -0,0 +1,180 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_ADAPTOR_TRAIT_H +#define SIGC_ADAPTORS_ADAPTOR_TRAIT_H + +#include //To get SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD +#include +#include +#include +#include +#include +#include + +/* + * The idea here is simple. To prevent the need to + * specializing every adaptor for every type of functor + * and worse non-functors like function pointers, we + * will make an adaptor trait which can take ordinary + * functors and make them adaptor functors for which + * we will of course be able to avoid excess copies. + * (in theory) + * + * this all depends on partial specialization to allow + * us to do + * functor_.template operator() (args); + * + * + * I don't understand much of the above. However, I can + * see that adaptors are implemented like they are because + * there is no way to extract the return type and the argument + * types from a functor type. Therefore, operator() is templated. + * It's instantiated in slot_call#<>::operator() where the + * argument types are known. The return type is finally determined + * via the callof<> template - a tricky way to detect the return + * type of a functor when the argument types are known. Martin. + */ + +namespace sigc +{ + +/** @defgroup adaptors Adaptors + * Adaptors are functors that alter the signature of a functor's + * operator()(). + * + * The adaptor types libsigc++ provides + * are created with bind(), bind_return(), hide(), hide_return(), + * retype_return(), retype(), compose(), exception_catch(), track_obj() + * and group(). + * + * You can easily derive your own adaptor type from sigc::adapts. + */ + +/** Converts an arbitrary functor into an adaptor type. + * All adaptor types in libsigc++ have + * a template operator() member of every argument count + * they support. These functions in turn invoke a stored adaptor's + * template operator(), processing the arguments and return + * value in a characteristic manner. Explicit function template + * instantiation is used to pass type hints thus saving copy costs. + * + * adaptor_functor is a glue between adaptors and arbitrary functors + * that just passes on the arguments. You won't use this type directly. + * + * The template argument @e T_functor determines the type of stored + * functor. + * + * @ingroup adaptors + */ +template +struct adaptor_functor : public adaptor_base +{ + /** Invokes the wrapped functor passing on the arguments. + * @return The return value of the functor invocation. + */ + decltype(auto) operator()() const { return functor_(); } + + /** Invokes the wrapped functor passing on the arguments. + * @param arg Arguments to be passed on to the functor. + * @return The return value of the functor invocation. + */ + template + decltype(auto) operator()(T_arg&&... arg) const + { + return std::invoke(functor_, std::forward(arg)...); + } + + /// Constructs an invalid functor. + adaptor_functor() = default; + + /** Constructs an adaptor_functor object that wraps the passed functor. + * @param functor Functor to invoke from operator()(). + */ + explicit adaptor_functor(const T_functor& functor) : functor_(functor) {} + + /** Constructs an adaptor_functor object that wraps the passed (member) + * function pointer. + * @param type Pointer to function or class method to invoke from operator()(). + */ + template + explicit adaptor_functor(const T_type& type) : functor_(type) + { + } + + /// Functor that is invoked from operator()(). + mutable T_functor functor_; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::adaptor_functor performs a functor + * on the functor stored in the sigc::adaptor_functor object. + * + * @ingroup adaptors + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, const adaptor_functor& target) + { + sigc::visit_each(action, target.functor_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** Trait that specifies what is the adaptor version of a functor type. + * Template specializations exist for sigc::adaptor_base-derived functors, + * for function pointers and for class methods. + * + * The template argument @e T_functor is the functor type to convert. + * @e I_isadaptor indicates whether @e T_functor inherits from sigc::adaptor_base. + * + * @ingroup adaptors + */ +template::value> +struct adaptor_trait; + +/** Trait that specifies the adaptor version of a functor type. + * This template specialization is used for types that inherit from adaptor_base. + * adaptor_type is equal to @p T_functor in this case. + */ +template +struct adaptor_trait +{ + using adaptor_type = T_functor; +}; + +/** Trait that specifies the adaptor version of a functor type. + * This template specialization is used for arbitrary functors, + * for function pointers and for class methods. + * The latter are converted into @p pointer_functor or @p mem_functor types. + * adaptor_type is equal to @p adaptor_functor. + */ +template +struct adaptor_trait +{ +private: + using functor_type = typename functor_trait::functor_type; + +public: + using adaptor_type = adaptor_functor; +}; + +} /* namespace sigc */ +#endif /* SIGC_ADAPTORS_ADAPTOR_TRAIT_H */ diff --git a/sigc++/adaptors/adaptors.h b/sigc++/adaptors/adaptors.h index 2353890e..81403913 100644 --- a/sigc++/adaptors/adaptors.h +++ b/sigc++/adaptors/adaptors.h @@ -1,6 +1,4 @@ -// -*- c++ -*- -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -13,12 +11,10 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_ADAPTOR_HPP_ -#define _SIGC_ADAPTOR_HPP_ +#ifndef SIGC_ADAPTOR_HPP +#define SIGC_ADAPTOR_HPP #include #include @@ -29,4 +25,4 @@ #include #include -#endif /* _SIGC_ADAPTOR_HPP_ */ +#endif /* SIGC_ADAPTOR_HPP */ diff --git a/sigc++/adaptors/adapts.h b/sigc++/adaptors/adapts.h new file mode 100644 index 00000000..50dd31c9 --- /dev/null +++ b/sigc++/adaptors/adapts.h @@ -0,0 +1,109 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_ADAPTS_H +#define SIGC_ADAPTORS_ADAPTS_H + +#include //To get SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD +#include +#include +#include +#include +#include + +namespace sigc +{ + +// Doxygen (at least version 1.8.4) removes blank lines in a code block. +// That's why there are empty comment lines in the following code block. +/** Base type for adaptors. + * sigc::adapts wraps adaptors, functors, function pointers and class methods. + * It contains a single member functor which is always a sigc::adaptor_base. + * The adaptor_type alias defines the exact type that is used + * to store the adaptor, functor, function pointer or class method passed + * into the constructor. It differs from @a T_functor unless @a T_functor + * inherits from sigc::adaptor_base. + * + * @par Example of a simple adaptor: + * @code + * namespace my_ns + * { + * template + * struct my_adaptor : public sigc::adapts + * { + * // + * decltype(auto) + * operator()() const; + * // + * template + * decltype(auto) + * operator()(T_arg1 arg1) const; + * // + * template + * decltype(auto) + * operator()(T_arg1 arg1, T_arg2 arg2) const; + * // + * // Constructs a my_adaptor object that wraps the passed functor. + * // Initializes adapts::functor_, which is invoked from operator()(). + * explicit my_adaptor(const T_functor& functor) + * : sigc::adapts(functor) {} + * }; + * } // end namespace my_ns + * // + * // Specialization of sigc::visitor for my_adaptor. + * namespace sigc + * { + * template + * struct visitor > + * { + * template + * static void do_visit_each(const T_action& action, + * const my_ns::my_adaptor& target) + * { + * sigc::visit_each(action, target.functor_); + * } + * }; + * } // end namespace sigc + * @endcode + * + * If you implement your own adaptor, you must also provide your specialization + * of sigc::visitor<>::do_visit_each<>() that will forward the call to the functor(s) + * your adapter is wrapping. Otherwise, pointers stored within the functor won't be + * invalidated when a sigc::trackable object is destroyed and you can end up + * executing callbacks on destroyed objects. + * + * Your specialization of sigc::visitor<> must be in namespace sigc. + * + * @ingroup adaptors + */ +template +struct adapts : public adaptor_base +{ +private: + using adaptor_type = typename adaptor_trait::adaptor_type; + +public: + /** Constructs an adaptor that wraps the passed functor. + * @param functor Functor to invoke from operator()(). + */ + explicit adapts(const T_functor& functor) : functor_(functor) {} + + /// Adaptor that is invoked from operator()(). + mutable adaptor_type functor_; +}; + +} /* namespace sigc */ +#endif /* SIGC_ADAPTORS_ADAPTS_H */ diff --git a/sigc++/adaptors/bind.h b/sigc++/adaptors/bind.h new file mode 100644 index 00000000..66af8ff9 --- /dev/null +++ b/sigc++/adaptors/bind.h @@ -0,0 +1,288 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_BIND_H +#define SIGC_ADAPTORS_BIND_H + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace sigc +{ + +/** @defgroup bind bind(), bind_return() + * sigc::bind() alters an arbitrary functor by fixing arguments to certain values. + * For single argument binding, overloads of sigc::bind() are provided that let you + * specify the zero-based position of the argument to fix with the first template parameter. + * (A value of @p -1 fixes the last argument so sigc::bind<-1>() gives the same result as + * sigc::bind().) + * The types of the arguments can optionally be specified if not deduced. + * + * @par Examples: + * @code + * void foo(int, int, int); + * // single argument binding ... + * sigc::bind(&foo,1)(2,3); //fixes the last (third) argument and calls foo(2,3,1) + * sigc::bind<-1>(&foo,1)(2,3); //same as bind(&foo,1)(2,3) (calls foo(2,3,1)) + * sigc::bind<0>(&foo,1)(2,3); //fixes the first argument and calls foo(1,2,3) + * sigc::bind<1>(&foo,1)(2,3); //fixes the second argument and calls foo(2,1,3) + * sigc::bind<2>(&foo,1)(2,3); //fixes the third argument and calls foo(2,3,1) + * // multi argument binding ... + * sigc::bind(&foo,1,2)(3); //fixes the last two arguments and calls foo(3,1,2) + * sigc::bind(&foo,1,2,3)(); //fixes all three arguments and calls foo(1,2,3) + * @endcode + * + * The functor that sigc::bind() returns can be passed directly into + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" or + * @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()". + * + * @par Example: + * @code + * sigc::signal some_signal; + * void foo(int); + * some_signal.connect(sigc::bind(&foo,1)); + * @endcode + * + * sigc::bind_return() alters an arbitrary functor by + * fixing its return value to a certain value. + * + * @par Example: + * @code + * void foo(); + * std::cout << sigc::bind_return(&foo, 5)(); // calls foo() and returns 5 + * @endcode + * + * You can bind references to functors by passing the objects through + * the std::ref() helper function. + * + * @par Example: + * @code + * int some_int; + * sigc::signal some_signal; + * void foo(int&); + * some_signal.connect(sigc::bind(&foo, std::ref(some_int))); + * @endcode + * + * If you bind an object of a sigc::trackable derived type to a functor + * by reference, a slot assigned to the bind adaptor is cleared automatically + * when the object goes out of scope. + * + * @par Example: + * @code + * struct bar : public sigc::trackable {} some_bar; + * sigc::signal some_signal; + * void foo(bar&); + * some_signal.connect(sigc::bind(&foo, std::ref(some_bar))); + * // disconnected automatically if some_bar goes out of scope + * @endcode + * + * @ingroup adaptors + */ + +namespace internal +{ + +template +struct TransformEachInvoker +{ + // We take T_element as non-const because invoke() is not const. + // TODO: Take element as T_element&& ? + constexpr static decltype(auto) transform(T_element& element) { return element.invoke(); } +}; + +} // namespace internal + +/** Adaptor that binds arguments to the wrapped functor. + * Use the convenience function sigc::bind() to create an instance of sigc::bind_functor. + * + * The following template arguments are used: + * - @e I_location Zero-based position of the argument to fix (@p -1 for the last argument). + * - @e T_bound Types of the bound argument. + * - @e T_functor Type of the functor to wrap. + * + * @ingroup bind + */ +template +struct bind_functor : public adapts +{ + /** Invokes the wrapped functor passing on the arguments. + * bound_ is passed as the next argument. + * @param arg Arguments to be passed on to the functor. + * @return The return value of the functor invocation. + */ + template + decltype(auto) operator()(T_arg&&... arg) + { + // For instance, if I_location is 1, and arg has 4 arguments, + // we would want to call operator() with (arg0, bound, arg1, arg2). + + using tuple_type_args = std::tuple...>; + const auto t_args = std::tuple(std::forward(arg)...); + constexpr auto t_args_size = std::tuple_size::value; + + // Prevent calling tuple_start<> with values that will cause a compilation error. + static_assert(I_location <= t_args_size, + "I_location must be less than or equal to the number of arguments."); + + const auto t_start = internal::tuple_start(t_args); + const auto t_bound = internal::tuple_transform_each(bound_); + const auto t_end = internal::tuple_end(t_args); + const auto t_with_bound = std::tuple_cat(t_start, t_bound, t_end); + + return std::apply(this->functor_, t_with_bound); + } + + /** Constructs a bind_functor object that binds an argument to the passed functor. + * @param func Functor to invoke from operator()(). + * @param bound Argument to bind to the functor. + */ + bind_functor(type_trait_take_t func, type_trait_take_t... bound) + : adapts(func), bound_(bound...) + { + } + + // public to avoid template friend declarations (used by visitor::do_visit_each()) + /// The arguments bound to the functor. + std::tuple...> bound_; +}; + +/** Adaptor that binds argument(s) to the wrapped functor. + * This template specialization fixes the last argument(s) of the wrapped functor. + * + * @ingroup bind + */ +template +struct bind_functor<-1, T_functor, T_type...> : public adapts +{ +public: + /** Invokes the wrapped functor passing on the arguments. + * bound_ is passed as the next argument. + * @param arg Arguments to be passed on to the functor. + * @return The return value of the functor invocation. + */ + template + decltype(auto) operator()(T_arg&&... arg) + { + // For instance, if arg has 4 arguments, + // we would want to call operator() with (arg0, arg1, arg2, bound). + + const auto t_args = std::tuple(std::forward(arg)...); + const auto t_bound = internal::tuple_transform_each(bound_); + const auto t_with_bound = std::tuple_cat(t_args, t_bound); + + return std::apply(this->functor_, t_with_bound); + } + + /** Constructs a bind_functor object that binds an argument to the passed functor. + * @param func Functor to invoke from operator()(). + * @param bound Arguments to bind to the functor. + */ + bind_functor(type_trait_take_t func, type_trait_take_t... bound) + : adapts(func), bound_(bound...) + { + } + + // public to avoid template friend declarations (used by visitor::do_visit_each()) + /// The argument bound to the functor. + std::tuple...> bound_; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::bind_functor performs a functor on the + * functor and on the object instances stored in the sigc::bind_functor object. + * + * @ingroup bind + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const bind_functor& target) + { + sigc::visit_each(action, target.functor_); + sigc::visit_each(action, std::get<0>(target.bound_)); + } +}; + +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::bind_functor performs a functor on the + * functor and on the object instances stored in the sigc::bind_functor object. + * + * @ingroup bind + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const bind_functor<-1, T_functor, T_type...>& target) + { + sigc::visit_each(action, target.functor_); + + sigc::internal::tuple_for_each(target.bound_, action); + } +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed + * functor. + * The optional template argument @e I_location specifies the zero-based + * position of the argument to be fixed (@p -1 stands for the last argument). + * + * @param func Functor that should be wrapped. + * @param b Arguments to bind to @e func. + * @return Adaptor that executes @e func with the bound argument on invocation. + * + * @ingroup bind + */ +template +inline decltype(auto) +bind(const T_functor& func, T_bound... b) +{ + return bind_functor(func, b...); +} + +/** Creates an adaptor of type sigc::bind_functor which fixes the last arguments of the passed + * functor. + * This function overload fixes the last arguments of @e func. + * + * @param func Functor that should be wrapped. + * @param b Arguments to bind to @e func. + * @return Adaptor that executes func with the bound argument on invocation. + * + * @ingroup bind + */ +template +inline decltype(auto) +bind(const T_functor& func, T_type... b) +{ + return bind_functor<-1, T_functor, T_type...>(func, b...); +} + +} /* namespace sigc */ + +#endif /* SIGC_ADAPTORS_BIND_H */ diff --git a/sigc++/adaptors/bind_return.h b/sigc++/adaptors/bind_return.h new file mode 100644 index 00000000..5c8a3348 --- /dev/null +++ b/sigc++/adaptors/bind_return.h @@ -0,0 +1,113 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_BIND_RETURN_H +#define SIGC_ADAPTORS_BIND_RETURN_H +#include +#include + +namespace sigc +{ + +/** Adaptor that fixes the return value of the wrapped functor. + * Use the convenience function sigc::bind_return() to create an instance of + * sigc::bind_return_functor. + * + * The following template arguments are used: + * - @e T_return Type of the fixed return value. + * - @e T_functor Type of the functor to wrap. + * + * @ingroup bind + */ +template +struct bind_return_functor : public adapts +{ + /** Invokes the wrapped functor dropping its return value. + * @return The fixed return value. + */ + typename unwrap_reference::type operator()(); + + /** Invokes the wrapped functor passing on the arguments. + * @param a Arguments to be passed on to the functor. + * @return The fixed return value. + */ + template + inline typename unwrap_reference::type operator()(T_arg... a) + { + std::invoke(this->functor_, a...); + return ret_value_.invoke(); + } + + /** Constructs a bind_return_functor object that fixes the return value to @p ret_value. + * @param functor Functor to invoke from operator()(). + * @param ret_value Value to return from operator()(). + */ + bind_return_functor(type_trait_take_t functor, type_trait_take_t ret_value) + : adapts(functor), ret_value_(ret_value) + { + } + + /// The fixed return value. + bound_argument ret_value_; // public, so that visit_each() can access it +}; + +template +typename unwrap_reference::type +bind_return_functor::operator()() +{ + std::invoke(this->functor_); + return ret_value_.invoke(); +} + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::bind_return_functor performs a functor on the + * functor and on the object instance stored in the sigc::bind_return_functor object. + * + * @ingroup bind + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const bind_return_functor& target) + { + sigc::visit_each(action, target.ret_value_); + sigc::visit_each(action, target.functor_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed + * functor to the passed argument. + * + * @param functor Functor that should be wrapped. + * @param ret_value Argument to fix the return value of @e functor to. + * @return Adaptor that executes @e functor on invocation and returns @e ret_value. + * + * @ingroup bind + */ +template +inline bind_return_functor +bind_return(const T_functor& functor, T_return ret_value) +{ + return bind_return_functor(functor, ret_value); +} + +} /* namespace sigc */ +#endif /* SIGC_ADAPTORS_BIND_RETURN_H */ diff --git a/sigc++/adaptors/bound_argument.h b/sigc++/adaptors/bound_argument.h index 05796827..a389b91e 100644 --- a/sigc++/adaptors/bound_argument.h +++ b/sigc++/adaptors/bound_argument.h @@ -1,5 +1,4 @@ -/* - * Copyright 2005, The libsigc++ Development Team +/* Copyright 2005 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,29 +11,28 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * License along with this library; if not, see . */ -#ifndef _SIGC_BOUND_ARGUMENT_H_ -#define _SIGC_BOUND_ARGUMENT_H_ - +#ifndef SIGC_BOUND_ARGUMENT_H +#define SIGC_BOUND_ARGUMENT_H #include #include +namespace sigc +{ -namespace sigc { - -/** A bound_argument object stores a bound (for instance, with sigc::bind(), or sigc::bind_return()) argument. +/** A bound_argument object stores a bound (for instance, with sigc::bind(), or + * sigc::bind_return()) argument. * - * If Foo is a wrapped reference to a class Bar (reference_wrapper) then this + * If Foo is a wrapped reference to a class Bar (std::reference_wrapper) then this * object is implemented on top of a limit_reference. When the slot is * invoked, the limit_reference::invoke() method provides the argument (a Bar&). * When the slot is visited (e.g. visit_each<>()), we simply visit the limit_reference, * which will visit the derived type, or a sigc::trackable base if necessary. * - * Likewise, If Foo is a wrapped const reference to a class Bar (const_reference_wrapper) + * Likewise, If Foo is a wrapped const reference to a class Bar (std::reference_wrapper) * then this object is implemented on top of a const_limit_reference. * * If Foo is something else (such as an argument that is bound by value) bound_argument just @@ -46,28 +44,24 @@ namespace sigc { * The general template implementation is used for parameters that are passed by value. * @e T_type The type of the bound argument. */ -template +template class bound_argument { public: /** Constructor. - * @param _A_argument The argument to bind. + * @param arg The argument to bind. */ - bound_argument(const T_type& _A_argument) - : visited_(_A_argument) - {} + bound_argument(const T_type& arg) : visited_(arg) {} /** Retrieve the entity to visit in visit_each(). * @return The bound argument. */ - inline const T_type& visit() const - { return visited_; } + inline const T_type& visit() const { return visited_; } /** Retrieve the entity to pass to the bound functor or return. * @return The bound argument. */ - inline T_type& invoke() - { return visited_; } + inline T_type& invoke() { return visited_; } private: /** The value of the argument. @@ -75,33 +69,29 @@ class bound_argument T_type visited_; }; -//Template specialization: +// Template specialization: /** bound_argument object for a bound argument that is passed by bind() or - * returned by bind_return() by reference, specialized for reference_wrapper<> types. + * returned by bind_return() by reference, specialized for std::reference_wrapper<> types. * @e T_wrapped The type of the bound argument. */ -template -class bound_argument< reference_wrapper > +template +class bound_argument> { public: /** Constructor. - * @param _A_argument The argument to bind. + * @param arg The argument to bind. */ - bound_argument(const reference_wrapper& _A_argument) - : visited_(unwrap(_A_argument)) - {} + bound_argument(const std::reference_wrapper& arg) : visited_(unwrap(arg)) {} /** Retrieve the entity to visit in visit_each(). * @return The limited_reference to the bound argument. */ - inline const limit_reference& visit() const - { return visited_; } + inline const limit_reference& visit() const { return visited_; } /** Retrieve the entity to pass to the bound functor or return. * @return The bound argument. */ - inline T_wrapped& invoke() - { return visited_.invoke(); } + inline T_wrapped& invoke() { return visited_.invoke(); } private: /** The limited_reference to the bound argument. @@ -113,33 +103,29 @@ class bound_argument< reference_wrapper > * returned by bind_return() by const reference, specialized for const reference_wrapper<> types. * - @e T_wrapped The type of the bound argument. */ -template -class bound_argument< const_reference_wrapper > +template +class bound_argument> { public: /** Constructor. - * @param _A_argument The argument to bind. + * @param arg The argument to bind. */ - bound_argument(const const_reference_wrapper& _A_argument) - : visited_(unwrap(_A_argument)) - {} + bound_argument(const std::reference_wrapper& arg) : visited_(unwrap(arg)) {} /** Retrieve the entity to visit in visit_each(). * @return The const_limited_reference to the bound argument. */ - inline const const_limit_reference& visit() const - { return visited_; } + inline const limit_reference& visit() const { return visited_; } /** Retrieve the entity to pass to the bound functor or return. * @return The bound argument. */ - inline const T_wrapped& invoke() - { return visited_.invoke(); } + inline const T_wrapped& invoke() { return visited_.invoke(); } private: /** The const_limited_reference to the bound argument. */ - const_limit_reference visited_; + limit_reference visited_; }; #ifndef DOXYGEN_SHOULD_SKIP_THIS @@ -148,22 +134,20 @@ class bound_argument< const_reference_wrapper > * method. * @tparam T_type The type of bound_argument. * @tparam T_action The type of functor to invoke. - * @param _A_action The functor to invoke. - * @param _A_argument The visited instance. + * @param action The functor to invoke. + * @param arg The visited instance. */ -template -struct visitor > +template +struct visitor> { - template - static void do_visit_each(const T_action& _A_action, - const bound_argument& _A_argument) + template + static void do_visit_each(const T_action& action, const bound_argument& arg) { - sigc::visit_each(_A_action, _A_argument.visit()); + sigc::visit_each(action, arg.visit()); } }; #endif // DOXYGEN_SHOULD_SKIP_THIS } /* namespace sigc */ - -#endif /* _SIGC_BOUND_ARGUMENT_H_ */ +#endif /* SIGC_BOUND_ARGUMENT_H */ diff --git a/sigc++/adaptors/compose.h b/sigc++/adaptors/compose.h new file mode 100644 index 00000000..b472d6a7 --- /dev/null +++ b/sigc++/adaptors/compose.h @@ -0,0 +1,193 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_COMPOSE_H +#define SIGC_ADAPTORS_COMPOSE_H +#include +#include + +namespace sigc +{ + +/** @defgroup compose compose() + * sigc::compose() combines two or three arbitrary functors. + * On invocation, parameters are passed on to one or two getter functor(s). + * The return value(s) are then passed on to the setter function. + * + * @par Examples: + * @code + * float square_root(float a) { return sqrtf(a); } + * float sum(float a, float b) { return a+b; } + * std::cout << sigc::compose(&square_root, &sum)(9, 16); // calls square_root(sum(3,6)) + * std::cout << sigc::compose(&sum, &square_root, &square_root)(9); // calls sum(square_root(9), + * square_root(9)) + * @endcode + * + * The functor that sigc::compose() returns can be passed directly into + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" or + * @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()". + * + * @par Example: + * @code + * sigc::signal(float(float, float)> some_signal; + * some_signal.connect(sigc::compose(&square_root, &sum)); + * @endcode + * + * @ingroup adaptors + */ + +/** Adaptor that combines two functors. + * Use the convenience function sigc::compose() to create an instance of sigc::compose1_functor. + * + * The following template arguments are used: + * - @e T_setter Type of the setter functor to wrap. + * - @e T_getter Type of the getter functor to wrap. + * + * @ingroup compose + */ +template +struct compose1_functor : public adapts +{ + template + decltype(auto) operator()(T_arg&&... a) + { + return std::invoke(this->functor_, get_(std::forward(a)...)); + } + + /** Constructs a compose1_functor object that combines the passed functors. + * @param setter Functor that receives the return values of the invocation of @e getter1 and + * @e getter2. + * @param getter Functor to invoke from operator()(). + */ + compose1_functor(const T_setter& setter, const T_getter& getter) + : adapts(setter), get_(getter) + { + } + + T_getter get_; // public, so that visit_each() can access it +}; + +/** Adaptor that combines three functors. + * Use the convenience function sigc::compose() to create an instance of sigc::compose2_functor. + * + * The following template arguments are used: + * - @e T_setter Type of the setter functor to wrap. + * - @e T_getter1 Type of the first getter functor to wrap. + * - @e T_getter2 Type of the second getter functor to wrap. + * + * @ingroup compose + */ +template +struct compose2_functor : public adapts +{ + template + decltype(auto) operator()(T_arg... a) + { + return std::invoke(this->functor_, get1_(a...), get2_(a...)); + } + + /** Constructs a compose2_functor object that combines the passed functors. + * @param setter Functor that receives the return values of the invocation of @e getter1 and + * @e getter2. + * @param getter1 Functor to invoke from operator()(). + * @param getter2 Functor to invoke from operator()(). + */ + compose2_functor(const T_setter& setter, const T_getter1& getter1, const T_getter2& getter2) + : adapts(setter), get1_(getter1), get2_(getter2) + { + } + + T_getter1 get1_; // public, so that visit_each() can access it + T_getter2 get2_; // public, so that visit_each() can access it +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::compose1_functor performs a functor on the + * functors stored in the sigc::compose1_functor object. + * + * @ingroup compose + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const compose1_functor& target) + { + sigc::visit_each(action, target.functor_); + sigc::visit_each(action, target.get_); + } +}; + +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::compose2_functor performs a functor on the + * functors stored in the sigc::compose2_functor object. + * + * @ingroup compose + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const compose2_functor& target) + { + sigc::visit_each(action, target.functor_); + sigc::visit_each(action, target.get1_); + sigc::visit_each(action, target.get2_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** Creates an adaptor of type sigc::compose1_functor which combines two functors. + * + * @param setter Functor that receives the return value of the invocation of @e getter. + * @param getter Functor to invoke from operator()(). + * @return Adaptor that executes @e setter with the value returned from invocation of @e + * getter. + * + * @ingroup compose + */ +template +inline compose1_functor +compose(const T_setter& setter, const T_getter& getter) +{ + return compose1_functor(setter, getter); +} + +/** Creates an adaptor of type sigc::compose2_functor which combines three functors. + * + * @param setter Functor that receives the return values of the invocation of @e getter1 and + * @e getter2. + * @param getter1 Functor to invoke from operator()(). + * @param getter2 Functor to invoke from operator()(). + * @return Adaptor that executes @e setter with the values return from invocation of @e + * getter1 and @e getter2. + * + * @ingroup compose + */ +template +inline compose2_functor +compose(const T_setter& setter, const T_getter1& getter1, const T_getter2& getter2) +{ + return compose2_functor(setter, getter1, getter2); +} + +} /* namespace sigc */ +#endif /* SIGC_ADAPTORS_COMPOSE_H */ diff --git a/sigc++/adaptors/exception_catch.h b/sigc++/adaptors/exception_catch.h new file mode 100644 index 00000000..b2528b6a --- /dev/null +++ b/sigc++/adaptors/exception_catch.h @@ -0,0 +1,134 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_EXCEPTION_CATCH_H +#define SIGC_ADAPTORS_EXCEPTION_CATCH_H +#include + +namespace sigc +{ + +/* + functor adaptor: exception_catch(functor, catcher) + + usage: + + + Future directions: + The catcher should be told what type of return it needs to + return for multiple type functors, to do this the user + will need to derive from catcher_base. +*/ +/** @defgroup exception_catch exception_catch() + * sigc::exception_catch() catches an exception thrown from within + * the wrapped functor and directs it to a catcher functor. + * This catcher can then rethrow the exception and catch it with the proper type. + * + * Note that the catcher is expected to return the same type + * as the wrapped functor so that normal flow can continue. + * + * Catchers can be cascaded to catch multiple types, because uncaught + * rethrown exceptions proceed to the next catcher adaptor. + * + * @par Examples: + * @code + * struct my_catch + * { + * int operator()() + * { + * try { throw; } + * catch (std::range_error e) // catch what types we know + * { std::cerr << "caught " << e.what() << std::endl; } + * return 1; + * } + * } + * int foo(); // throws std::range_error + * sigc::exception_catch(&foo, my_catch())(); + * @endcode + * + * The functor that sigc::exception_catch() returns can be passed directly into + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" or + * @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()". + * + * @par Example: + * @code + * sigc::signal some_signal; + * some_signal.connect(sigc::exception_catch(&foo, my_catch)); + * @endcode + * + * @ingroup adaptors + */ + +template +struct exception_catch_functor : public adapts +{ + decltype(auto) operator()() + { + try + { + return std::invoke(this->functor_); + } + catch (...) + { + return catcher_(); + } + } + + template + decltype(auto) operator()(T_arg... a) + { + try + { + return std::invoke(this->functor_, a...); + } + catch (...) + { + return catcher_(); + } + } + + exception_catch_functor(const T_functor& func, const T_catcher& catcher) + : adapts(func), catcher_(catcher) + { + } + + T_catcher catcher_; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const exception_catch_functor& target) + { + sigc::visit_each(action, target.functor_); + sigc::visit_each(action, target.catcher_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +template +inline decltype(auto) +exception_catch(const T_functor& func, const T_catcher& catcher) +{ + return exception_catch_functor(func, catcher); +} + +} /* namespace sigc */ +#endif /* SIGC_ADAPTORS_EXCEPTION_CATCH_H */ diff --git a/sigc++/adaptors/hide.h b/sigc++/adaptors/hide.h new file mode 100644 index 00000000..2dbdb4ae --- /dev/null +++ b/sigc++/adaptors/hide.h @@ -0,0 +1,167 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_HIDE_H +#define SIGC_ADAPTORS_HIDE_H + +#include +#include +#include + +namespace sigc +{ + +/** @defgroup hide hide(), hide_return() + * sigc::hide() alters an arbitrary functor in that it adds a parameter + * whose value is ignored on invocation of the returned functor. + * Thus you can discard one argument of a signal. + * + * You may optionally specify the zero-based position of the parameter + * to ignore as a template argument. The default is to ignore the last + * parameter. + * (A value of @p -1 adds a parameter at the end so sigc::hide<-1>() gives the same result as + sigc::hide().) + * + * The type of the parameter can optionally be specified if not deduced. + * + * @par Examples: + * @code + * void foo(int, int); + * // single argument hiding ... + * sigc::hide(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2) + * sigc::hide<-1>(&foo)(1,2,3); // same as sigc::hide(&foo)(1,2,3) (calls foo(1,2)) + * sigc::hide<0>(&foo)(1,2,3); // adds a dummy parameter at the beginning and calls foo(2,3) + * sigc::hide<1>(&foo)(1,2,3); // adds a dummy parameter in the middle and calls foo(1,3) + * sigc::hide<2>(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2) + * @endcode + * + * The functor that sigc::hide() returns can be passed directly into + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" or + * @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()". + * + * @par Example: + * @code + * sigc::signal some_signal; + * void foo(); + * some_signal.connect(sigc::hide(&foo)); + * @endcode + * + * sigc::hide() can be nested in order to discard multiple arguments. + * @par Example: + * @code + * // multiple argument hiding ... + * // adds two dummy parameters at the back and calls foo(1,2) + * sigc::hide(sigc::hide(&foo))(1,2,3,4); + * @endcode + + * sigc::hide_return() alters an arbitrary functor by + * dropping its return value, thus converting it to a void functor. + * + * @ingroup adaptors + */ + +/** Adaptor that adds a dummy parameter to the wrapped functor. + * Use the convenience function sigc::hide() to create an instance of sigc::hide_functor. + * + * The following template arguments are used: + * - @e I_location Zero-based position of the dummy parameter (@p -1 for the last parameter). + * - @e T_functor Type of the functor to wrap. + * + * @ingroup hide + */ +template +struct hide_functor : public adapts +{ + /** Invokes the wrapped functor, ignoring the argument at index @e I_location (0-indexed). + * @param a Arguments to be passed on to the functor, apart from the ignored argument. + * @return The return value of the functor invocation. + */ + template + decltype(auto) operator()(T_arg&&... a) + { + constexpr auto size = sizeof...(T_arg); + constexpr auto index_ignore = (I_location == -1 ? size - 1 : I_location); + const auto t = std::tuple(std::forward(a)...); + + const auto t_start = internal::tuple_start(t); + const auto t_end = internal::tuple_end(t); + const auto t_used = std::tuple_cat(t_start, t_end); + + return std::apply(this->functor_, t_used); + } + + /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. + * @param func Functor to invoke from operator()(). + */ + explicit hide_functor(const T_functor& func) : adapts(func) {} +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::hide_functor performs a functor on the + * functor stored in the sigc::hide_functor object. + * + * @ingroup hide + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const hide_functor& target) + { + sigc::visit_each(action, target.functor_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed + * functor. + * The optional template argument @e I_location specifies the zero-based + * position of the dummy parameter in the returned functor (@p -1 stands for the last parameter). + * + * @param func Functor that should be wrapped. + * @return Adaptor that executes @e func, ignoring the value of the dummy parameter. + * + * @ingroup hide + */ +template +inline decltype(auto) +hide(const T_functor& func) +{ + return hide_functor(func); +} + +/** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed + * functor. + * This overload adds a dummy parameter at the back of the functor's parameter list. + * + * @param func Functor that should be wrapped. + * @return Adaptor that executes @e func, ignoring the value of the last parameter. + * + * @ingroup hide + */ +template +inline decltype(auto) +hide(const T_functor& func) +{ + return hide_functor<-1, T_functor>(func); +} + +} /* namespace sigc */ + +#endif /* SIGC_ADAPTORS_HIDE_H */ diff --git a/sigc++/adaptors/lambda/macros/base.h.m4 b/sigc++/adaptors/lambda/macros/base.h.m4 deleted file mode 100644 index 083bf851..00000000 --- a/sigc++/adaptors/lambda/macros/base.h.m4 +++ /dev/null @@ -1,210 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) -include(template.macros.m4) - -define([LAMBDA_DO],[dnl - template - typename deduce_result_type::type - operator ()(LOOP(T_arg%1 _A_%1, $1)) const - { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_%1, $1)); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LOOP(T_arg%1 _A_%1, $1)) const - { return value_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_%1, $1)); - } - #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - -])dnl -define([LAMBDA_DO_VALUE],[dnl - template - result_type operator ()(LOOP(T_arg%1, $1)) const - { return value_; } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - result_type sun_forte_workaround(LOOP(T_arg%1, $1)) const - { return value_; } - #endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - -])dnl - -divert(0)dnl -#ifndef _SIGC_LAMBDA_BASE_HPP_ -#define _SIGC_LAMBDA_BASE_HPP_ -#include -#include -#include - -_DEPRECATE_IFDEF_START - -namespace sigc { - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -// libsigc++'s lambda functions have been removed from the API. -// Some code must be kept until we can break ABI. -/** @defgroup lambdas Lambdas - * libsigc++ ships with basic lambda functionality and the sigc::group adaptor, - * which uses lambdas to transform a functor's parameter list. - * - * The lambda selectors sigc::_1, sigc::_2, ..., sigc::_7 are used to select the - * first, second, ..., seventh argument from a list. - * - * @par Examples: - * @code - * std::cout << sigc::_1(10,20,30); // returns 10 - * std::cout << sigc::_2(10,20,30); // returns 20 - * @endcode - * - * Operators are defined so that, for example, lambda selectors can be used as - * placeholders in arithmetic expressions. - * - * @par Examples: - * @code - * std::cout << (sigc::_1 + 5)(3); // returns (3 + 5) - * std::cout << (sigc::_1 * sigc::_2)(7,10); // returns (7 * 10) - * @endcode - * - * If your compiler supports C++11 lambda expressions, they are often a good - * alternative to libsigc++'s lambda expressions. The following examples are - * equivalent to the previous ones. - * @code - * [[]] (int x, int, int) -> int { return x; }(10,20,30); // returns 10 - * [[]] (int, int y, int) -> int { return y; }(10,20,30); // returns 20 - * [[]] (int x) -> int { return x + 5; }(3); // returns (3 + 5) - * [[]] (int x, int y) -> int { return x * y; }(7,10); // returns (7 * 10) - * @endcode - * - * @deprecated Use C++11 lambda expressions or %std::bind() instead. - */ - -/** A hint to the compiler. - * All lambda types publically inherit from this hint. - * - * @deprecated Use C++11 lambda expressions instead. - * - * @ingroup lambdas - */ -struct lambda_base : public adaptor_base {}; - -// Forward declaration of lambda. -template struct lambda; - -namespace internal { - -/** Abstracts lambda functionality. - * Objects of this type store a value that may be of type lambda itself. - * In this case, operator()() executes the lambda (a lambda is always a functor at the same time). - * Otherwise, operator()() simply returns the stored value. - * - * @deprecated Use C++11 lambda expressions instead. - * - * @ingroup lambdas - */ -template ::value> struct lambda_core; - -/** Abstracts lambda functionality (template specialization for lambda values). - * - * @deprecated Use C++11 lambda expressions instead. - * - * @ingroup lambdas - */ -template -struct lambda_core : public lambda_base -{ - template - struct deduce_result_type - { typedef typename T_type::template deduce_result_type::type type; }; - typedef typename T_type::result_type result_type; - typedef T_type lambda_type; - - result_type - operator()() const; - -FOR(1,CALL_SIZE,[[LAMBDA_DO(%1)]])dnl - lambda_core() {} - - explicit lambda_core(const T_type& v) - : value_(v) {} - - T_type value_; -}; - - -} /* namespace internal */ - - -// forward declarations for lambda operators other and other -template -struct other; -struct subscript; -struct assign; - -template -struct lambda_operator; - -template -struct unwrap_lambda_type; - -/** Lambda type. - * Objects of this type store a value that may be of type lambda itself. - * In this case, operator()() executes the lambda (a lambda is always a functor at the same time). - * Otherwise, operator()() simply returns the stored value. - * The assign and subscript operators are defined to return a lambda operator. - * - * @deprecated Use C++11 lambda expressions instead. - * - * @ingroup lambdas - */ -template -struct lambda : public internal::lambda_core -{ - typedef lambda self; - - lambda() - {} - - lambda(typename type_trait::take v) - : internal::lambda_core(v) - {} - - // operators for other - template - lambda, self, typename unwrap_lambda_type::type> > - operator [[]] (const T_arg& a) const - { typedef lambda_operator, self, typename unwrap_lambda_type::type> lambda_operator_type; - return lambda(lambda_operator_type(this->value_, unwrap_lambda_value(a))); } - - // operators for other - template - lambda, self, typename unwrap_lambda_type::type> > - operator = (const T_arg& a) const - { typedef lambda_operator, self, typename unwrap_lambda_type::type> lambda_operator_type; - return lambda(lambda_operator_type(this->value_, unwrap_lambda_value(a))); } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -} /* namespace sigc */ - -_DEPRECATE_IFDEF_END - -#endif /* _SIGC_LAMBDA_BASE_HPP_ */ diff --git a/sigc++/adaptors/lambda/macros/lambda.cc.m4 b/sigc++/adaptors/lambda/macros/lambda.cc.m4 deleted file mode 100644 index f9fa909f..00000000 --- a/sigc++/adaptors/lambda/macros/lambda.cc.m4 +++ /dev/null @@ -1,36 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) -include(template.macros.m4) -divert(0)dnl -#include - -_DEPRECATE_IFDEF_START - -namespace sigc { - -// sigc::_1 .. sigc::_7 must be kept until we can break ABI. -// See https://bugzilla.gnome.org/show_bug.cgi?id=755550 -// The extern declarations have been moved from select.h, to keep them out of the API. -// Without them the const sigc::_1 .. sigc::_7 would be local to this .cc file. -FOR(1,CALL_SIZE,[[extern SIGC_API const lambda _%1; -]]) -FOR(1,CALL_SIZE,[[const lambda _%1; -]]) -} /* namespace sigc */ - -_DEPRECATE_IFDEF_END diff --git a/sigc++/adaptors/lambda/macros/select.h.m4 b/sigc++/adaptors/lambda/macros/select.h.m4 deleted file mode 100644 index ab512a66..00000000 --- a/sigc++/adaptors/lambda/macros/select.h.m4 +++ /dev/null @@ -1,77 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) -include(template.macros.m4) - -dnl -dnl Macros to make select arguments -define([LAMBDA_SELECT_DO],[dnl - template -dnl T_arg$1 operator ()(LOOP(T_arg%1 _A_%1, $2)) const { return _A_$1; } - T_arg$1 operator ()(LIST(FOR(1,eval($1-1),[T_arg%1,]),T_arg$1 _A_$1,FOR(eval($1+1),$2,[T_arg%1,]))) const { return _A_$1; } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - //Does not work: T_arg$1 sun_forte_workaround(LOOP(T_arg%1 _A_%1, $2)) const { return operator()( LOOP(_A_%1, $2) ); } - T_arg$1 sun_forte_workaround(LIST(FOR(1,eval($1-1),[T_arg%1,]),T_arg$1 _A_$1,FOR(eval($1+1),$2,[T_arg%1,]))) const { return _A_$1; } - #endif - -]) -define([LAMBDA_SELECT],[dnl -struct lambda_select$1 : public lambda_base -{ - template - struct deduce_result_type - { typedef T_arg$1 type; }; - typedef void result_type; // no operator ()() overload - - void operator ()() const; // not implemented -FOR($1, $2,[[LAMBDA_SELECT_DO($1,%1)]])dnl -}; - -]) -define([LAMBDA_SELECTOR],[dnl -/** Lambda selector. - * - * @deprecated Use C++11 lambda expressions or %std::bind() instead of libsigc++ lambdas and sigc::group(). - * - * @ingroup lambdas - */ -extern SIGC_API const lambda _$1; - -]) - -divert(0)dnl -#ifndef _SIGC_LAMBDA_SELECT_HPP_ -#define _SIGC_LAMBDA_SELECT_HPP_ -#include - -_DEPRECATE_IFDEF_START - -namespace sigc { - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -namespace internal { -FOR(1,CALL_SIZE,[[LAMBDA_SELECT(%1,CALL_SIZE)]])dnl -} /* namespace internal */ - -#endif // DOXYGEN_SHOULD_SKIP_THIS -} /* namespace sigc */ - -_DEPRECATE_IFDEF_END - -#endif /* _SIGC_LAMBDA_SELECT_HPP_ */ diff --git a/sigc++/adaptors/macros/adaptor_trait.h.m4 b/sigc++/adaptors/macros/adaptor_trait.h.m4 deleted file mode 100644 index a7a06137..00000000 --- a/sigc++/adaptors/macros/adaptor_trait.h.m4 +++ /dev/null @@ -1,326 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) -include(template.macros.m4) - -dnl -dnl The idea here is simple. To prevent the need to -dnl specializing every adaptor for every type of functor -dnl and worse non-functors like function pointers, we -dnl will make an adaptor trait which can take ordinary -dnl functors and make them adaptor functors for which -dnl we will of course be able to avoid excess copies. -dnl (in theory) -dnl -dnl this all depends on partial specialization to allow -dnl us to do -dnl functor_.template operator() (args); -dnl - -dnl I don't understand much of the above. However, I can -dnl see that adaptors are implemented like they are because -dnl there is no way to extract the return type and the argument -dnl types from a functor type. Therefore, operator() is templated. -dnl It's instatiated in slot_call#<>::operator() where the -dnl argument types are known. The return type is finally determined -dnl via the callof<> template - a tricky way to detect the return -dnl type of a functor when the argument types are known. Martin. - -]) -define([ADAPTOR_DO],[dnl -ifelse($1,0,[dnl -dnl typename internal::callof_safe0::result_type // doesn't compile if T_functor has an overloaded operator()! -dnl typename functor_trait::result_type -dnl operator()() const -dnl { return functor_(); } -],[dnl - /** Invokes the wrapped functor passing on the arguments.dnl -FOR(1, $1,[ - * @param _A_arg%1 Argument to be passed on to the functor.]) - * @return The return value of the functor invocation. - */ - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_arg%1, $1)) const - { return functor_(LOOP(_A_arg%1, $1)); } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LOOP(T_arg%1 _A_arg%1, $1)) const - { //Just calling operator() tries to copy the argument: - return functor_(LOOP(_A_arg%1, $1)); - } - #endif - -])dnl -]) - -divert(0)dnl -_FIREWALL([ADAPTORS_ADAPTOR_TRAIT]) -#include //To get SIGC_TEMPLATE_KEYWORD_OPERATOR_OVERLOAD -#include -#include -#include -#include -#include - -namespace sigc { - -// Call either operator()<>() or sun_forte_workaround<>(), -// depending on the compiler: -#ifdef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - #define SIGC_WORKAROUND_OPERATOR_PARENTHESES template operator() - #define SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD -#else - #ifdef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - #define SIGC_WORKAROUND_OPERATOR_PARENTHESES operator() - #define SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - #else - #define SIGC_WORKAROUND_OPERATOR_PARENTHESES sun_forte_workaround - #endif -#endif - - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -template struct adapts; -#endif - -/** @defgroup adaptors Adaptors - * Adaptors are functors that alter the signature of a functor's - * operator()(). - * - * The adaptor types libsigc++ provides - * are created with bind(), bind_return(), hide(), hide_return(), - * retype_return(), retype(), compose(), exception_catch(), track_obj() - * and group(). - * - * You can easily derive your own adaptor type from sigc::adapts. - */ - -/** Converts an arbitrary functor into an adaptor type. - * All adaptor types in libsigc++ have - * a template operator() member of every argument count - * they support. These functions in turn invoke a stored adaptor's - * template operator(), processing the arguments and return - * value in a characteristic manner. Explicit function template - * instantiation is used to pass type hints thus saving copy costs. - * - * adaptor_functor is a glue between adaptors and arbitrary functors - * that just passes on the arguments. You won't use this type directly. - * - * The template argument @e T_functor determines the type of stored - * functor. - * - * @ingroup adaptors - */ -template -struct adaptor_functor : public adaptor_base -{ -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef sigc::deduce_result_t type; }; -#endif - typedef typename functor_trait::result_type result_type; - - /** Invokes the wrapped functor passing on the arguments. - * @return The return value of the functor invocation. - */ - result_type - operator()() const; - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - result_type sun_forte_workaround() const - { return operator(); } - #endif - -FOR(0,CALL_SIZE,[[ADAPTOR_DO(%1)]])dnl - /// Constructs an invalid functor. - adaptor_functor() - {} - - /** Constructs an adaptor_functor object that wraps the passed functor. - * @param _A_functor Functor to invoke from operator()(). - */ - explicit adaptor_functor(const T_functor& _A_functor) - : functor_(_A_functor) - {} - - /** Constructs an adaptor_functor object that wraps the passed (member) - * function pointer. - * @param _A_type Pointer to function or class method to invoke from operator()(). - */ - template - explicit adaptor_functor(const T_type& _A_type) - : functor_(_A_type) - {} - - /// Functor that is invoked from operator()(). - mutable T_functor functor_; -}; - -template -typename adaptor_functor::result_type -adaptor_functor::operator()() const - { return functor_(); } - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::adaptor_functor performs a functor - * on the functor stored in the sigc::adaptor_functor object. - * - * @ingroup adaptors - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const adaptor_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Trait that specifies what is the adaptor version of a functor type. - * Template specializations for sigc::adaptor_base derived functors, - * for function pointers and for class methods are provided. - * - * The template argument @e T_functor is the functor type to convert. - * @e I_isadaptor indicates whether @e T_functor inherits from sigc::adaptor_base. - * - * @ingroup adaptors - */ -#ifndef DOXYGEN_SHOULD_SKIP_THIS -template ::value> struct adaptor_trait; -#else -template ::value> struct adaptor_trait {}; -#endif - -/** Trait that specifies what is the adaptor version of a functor type. - * This template specialization is used for types that inherit from adaptor_base. - * adaptor_type is equal to @p T_functor in this case. - */ -template -struct adaptor_trait -{ - typedef typename T_functor::result_type result_type; - typedef T_functor functor_type; - typedef T_functor adaptor_type; -}; - -/** Trait that specifies what is the adaptor version of a functor type. - * This template specialization is used for arbitrary functors, - * for function pointers and for class methods are provided. - * The latter are converted into @p pointer_functor or @p mem_functor types. - * adaptor_type is equal to @p adaptor_functor. - */ -template -struct adaptor_trait -{ - typedef typename functor_trait::result_type result_type; - typedef typename functor_trait::functor_type functor_type; - typedef adaptor_functor adaptor_type; -}; - -// Doxygen (at least version 1.8.4) removes blank lines in a code block. -// That's why there are empty comment lines in the following code block. -/** Base type for adaptors. - * sigc::adapts wraps adaptors, functors, function pointers and class methods. - * It contains a single member functor which is always a sigc::adaptor_base. - * The typedef adaptor_type defines the exact type that is used - * to store the adaptor, functor, function pointer or class method passed - * into the constructor. It differs from @a T_functor unless @a T_functor - * inherits from sigc::adaptor_base. - * - * @par Example of a simple adaptor: - * @code - * namespace my_ns - * { - * template - * struct my_adaptor : public sigc::adapts - * { - * template - * struct deduce_result_type - * { typedef sigc::deduce_result_t type; }; - * typedef typename sigc::functor_trait::result_type result_type; - * // - * result_type - * operator()() const; - * // - * template - * typename deduce_result_type::type - * operator()(T_arg1 _A_arg1) const; - * // - * template - * typename deduce_result_type::type - * operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const; - * // - * // Constructs a my_adaptor object that wraps the passed functor. - * // Initializes adapts::functor_, which is invoked from operator()(). - * explicit my_adaptor(const T_functor& _A_functor) - * : sigc::adapts(_A_functor) {} - * }; - * } // end namespace my_ns - * // - * // Specialization of sigc::visitor for my_adaptor. - * namespace sigc - * { - * template - * struct visitor > - * { - * template - * static void do_visit_each(const T_action& _A_action, - * const my_ns::my_adaptor& _A_target) - * { - * sigc::visit_each(_A_action, _A_target.functor_); - * } - * }; - * } // end namespace sigc - * @endcode - * - * If you implement your own adaptor, you must also provide your specialization - * of sigc::visitor<>::do_visit_each<>() that will forward the call to the functor(s) - * your adapter is wrapping. Otherwise, pointers stored within the functor won't be - * invalidated when a sigc::trackable object is destroyed and you can end up - * executing callbacks on destroyed objects. - * - * Your specialization of sigc::visitor<> must be in namespace sigc. - * - * @ingroup adaptors - */ -template -struct adapts : public adaptor_base -{ - typedef typename adaptor_trait::result_type result_type; - typedef typename adaptor_trait::adaptor_type adaptor_type; - - /** Constructs an adaptor that wraps the passed functor. - * @param _A_functor Functor to invoke from operator()(). - */ - explicit adapts(const T_functor& _A_functor) - : functor_(_A_functor) - {} - - /// Adaptor that is invoked from operator()(). - mutable adaptor_type functor_; -}; - -} /* namespace sigc */ diff --git a/sigc++/adaptors/macros/bind.h.m4 b/sigc++/adaptors/macros/bind.h.m4 deleted file mode 100644 index 495f7fb3..00000000 --- a/sigc++/adaptors/macros/bind.h.m4 +++ /dev/null @@ -1,417 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([ORDINAL],[dnl -$1[]ifelse($1,1,[st],$1,2,[nd],$1,3,[rd],[th])[]dnl -]) -define([DEDUCE_RESULT_TYPE_COUNT],[dnl - template - struct deduce_result_type_internal - { typedef typename adaptor_type::template deduce_result_type::type), $1))>::type type; }; -]) -define([BIND_OPERATOR_LOCATION],[dnl -ifelse($2,1,,[dnl - /** Invokes the wrapped functor passing on the arguments. - * bound_ is passed as the ORDINAL($1) argument.dnl -FOR(1, eval($2-1),[ - * @param _A_arg%1 Argument to be passed on to the functor.]) - * @return The return value of the functor invocation. - */ - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_arg%1,eval($2-1))) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES::type), FOR($1,eval($2-1),[_P_(T_arg%1),]))> - (LIST(LOOP(_A_arg%1,eval($1-1)), bound_.invoke(), FOR($1,eval($2-1),[_A_arg%1,]))); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LOOP(T_arg%1 _A_arg%1,eval($2-1))) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES::type), FOR($1,eval($2-1),[_P_(T_arg%1),]))> - (LIST(LOOP(_A_arg%1,eval($1-1)), bound_.invoke(), FOR($1,eval($2-1),[_A_arg%1,]))); - } - #endif - -])dnl -]) -define([BIND_OPERATOR_COUNT],[dnl - /** Invokes the wrapped functor passing on the arguments. - * The last $1 argument(s) are fixed.dnl -FOR(1, eval($2-1),[ - * @param _A_arg%1 Argument to be passed on to the functor.]) - * @return The return value of the functor invocation. - */ - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_arg%1, eval($2-1))) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES::type), $1))> - (LIST(LOOP(_A_arg%1,eval($2-1)), LOOP(bound%1_.invoke(), $1))); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LOOP(T_arg%1 _A_arg%1, eval($2-1))) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES::type), $1))> - (LIST(LOOP(_A_arg%1,eval($2-1)), LOOP(bound%1_.invoke(), $1))); - } - #endif - -]) -define([BIND_FUNCTOR_LOCATION],[dnl -ifelse($1,1,[#ifndef DOXYGEN_SHOULD_SKIP_THIS -],)dnl Include only the first template specialization in the documentation. ($1 = 0..CALL_SIZE-1) -/** Adaptor that binds an argument to the wrapped functor. - * This template specialization fixes the ORDINAL(eval($1+1)) argument of the wrapped functor. - * - * @ingroup bind - */ -template -struct bind_functor<$1, T_functor, T_bound, LIST(LOOP(nil, CALL_SIZE - 1))> : public adapts -{ - typedef typename adapts::adaptor_type adaptor_type; - -ifelse($1,0,[#ifndef DOXYGEN_SHOULD_SKIP_THIS -],)dnl - template - struct deduce_result_type - { typedef typename adaptor_type::template deduce_result_type::type), FOR(eval($1+1),eval(CALL_SIZE-1),[_P_(T_arg%1),]))>::type type; }; -ifelse($1,0,[#endif -],)dnl - typedef typename adaptor_type::result_type result_type; - - /** Invokes the wrapped functor passing on the bound argument only. - * @return The return value of the functor invocation. - */ - result_type - operator()() - { - //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class. - return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<_P_(typename unwrap_reference::type)> (bound_.invoke()); - } - -FOR(eval($1+1),CALL_SIZE,[[BIND_OPERATOR_LOCATION(eval($1+1),%1)]])dnl - /** Constructs a bind_functor object that binds an argument to the passed functor. - * @param _A_func Functor to invoke from operator()(). - * @param _A_bound Argument to bind to the functor. - */ - bind_functor(_R_(T_functor) _A_func, _R_(T_bound) _A_bound) - : adapts(_A_func), bound_(_A_bound) - {} - - /// The argument bound to the functor. - bound_argument bound_; -}; -ifelse($1,eval(CALL_SIZE-1),[#endif // DOXYGEN_SHOULD_SKIP_THIS -],)dnl Include only the first template specialization in the documentation. ($1 = 0..CALL_SIZE-1) - -])dnl end BIND_FUNCTOR_LOCATION - -define([BIND_FUNCTOR_COUNT],[dnl -/** Adaptor that binds $1 argument(s) to the wrapped functor. - * This template specialization fixes the last $1 argument(s) of the wrapped functor. - * - * @ingroup bind - */ -template -struct bind_functor : public adapts -{ - typedef typename adapts::adaptor_type adaptor_type; - -ifelse($1,1,[#ifndef DOXYGEN_SHOULD_SKIP_THIS -],)dnl - template - struct deduce_result_type_internal - { typedef typename adaptor_type::template deduce_result_type::type), $1))>::type type; }; -FOR(eval($1+1),eval(CALL_SIZE-1),[[DEDUCE_RESULT_TYPE_COUNT($1,%1)]])dnl - - template - struct deduce_result_type { - typedef typename deduce_result_type_internal::value, - LOOP(T_arg%1, eval(CALL_SIZE))>::type type; - }; -ifelse($1,1,[#endif // DOXYGEN_SHOULD_SKIP_THIS -],)dnl - typedef typename adaptor_type::result_type result_type; - - /** Invokes the wrapped functor passing on the bound argument only. - * @return The return value of the functor invocation. - */ - result_type - operator()() - { - //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class. - return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES::type), $1)> (LOOP(bound%1_.invoke(), $1)); - } - -FOR(2,eval(CALL_SIZE-$1+1),[[BIND_OPERATOR_COUNT($1,%1)]])dnl - /** Constructs a bind_functor object that binds an argument to the passed functor. - * @param _A_func Functor to invoke from operator()().dnl -FOR(1,$1,[ - * @param _A_bound%1 Argument to bind to the functor.]) - */ - bind_functor(_R_(T_functor) _A_func, LOOP(_R_(T_type%1) _A_bound%1, $1)) - : adapts(_A_func), LOOP(bound%1_(_A_bound%1), $1) - {} - - /// The argument bound to the functor.dnl -FOR(1,$1,[ - bound_argument bound%1_;]) -}; - -ifelse($1,1,[#ifndef DOXYGEN_SHOULD_SKIP_THIS -],)dnl Include only the first template specialization of bind_functor and no -dnl template specialization of visitor in the documentation. ($1 = 1..CALL_SIZE) -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::bind_functor performs a functor on the - * functor and on the object instances stored in the sigc::bind_functor object. - * - * @ingroup bind - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const bind_functor<-1, T_functor, LOOP(T_type%1, $1)>& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_);dnl -FOR(1,$1,[ - sigc::visit_each(_A_action, _A_target.bound%1_);]) - } -}; -ifelse($1,CALL_SIZE,[#endif // DOXYGEN_SHOULD_SKIP_THIS -],)dnl - -])dnl end BIND_FUNCTOR_COUNT - -define([BIND_COUNT],[dnl -/** Creates an adaptor of type sigc::bind_functor which fixes the last $1 argument(s) of the passed functor. - * This function overload fixes the last $1 argument(s) of @e _A_func. - * - * @param _A_func Functor that should be wrapped.dnl -FOR(1,$1,[ - * @param _A_b%1 Argument to bind to @e _A_func.]) - * @return Adaptor that executes _A_func with the bound argument on invokation. - * - * @ingroup bind - */ -template -inline bind_functor<-1, T_functor,dnl -FOR(1,eval($1-1),[ - T_type%1,]) - T_type$1> -bind(const T_functor& _A_func, LOOP(T_type%1 _A_b%1, $1)) -{ return bind_functor<-1, T_functor,dnl -FOR(1,eval($1-1),[ - T_type%1,]) - T_type$1> - (_A_func, LOOP(_A_b%1, $1)); -} - -]) - -divert(0)dnl -_FIREWALL([ADAPTORS_BIND]) -#include -#include - -//TODO: See comment in functor_trait.h. -#if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO) - #define SIGC_NIL_HAS_BEEN_PUSHED 1 - #pragma push_macro("nil") - #undef nil -#endif - -namespace sigc { - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - -namespace internal { - -template -struct count_void - { static const int value=0; }; -template -struct count_void - { static const int value=1; }; -template -struct count_void - { static const int value=2; }; -template -struct count_void - { static const int value=3; }; -template -struct count_void - { static const int value=4; }; -template -struct count_void - { static const int value=5; }; -template -struct count_void - { static const int value=6; }; -template <> -struct count_void - { static const int value=7; }; - -} /* namespace internal */ - -#endif /*DOXYGEN_SHOULD_SKIP_THIS*/ - - -/** @defgroup bind bind(), bind_return() - * sigc::bind() alters an arbitrary functor by fixing arguments to certain values. - * Up to CALL_SIZE arguments can be bound at a time. - * For single argument binding, overloads of sigc::bind() are provided that let you - * specify the zero-based position of the argument to fix with the first template parameter. - * (A value of @p -1 fixes the last argument so sigc::bind<-1>() gives the same result as sigc::bind().) - * The types of the arguments can optionally be specified if not deduced. - * - * @par Examples: - * @code - * void foo(int, int, int); - * // single argument binding ... - * sigc::bind(&foo,1)(2,3); //fixes the last (third) argument and calls foo(2,3,1) - * sigc::bind<-1>(&foo,1)(2,3); //same as bind(&foo,1)(2,3) (calls foo(2,3,1)) - * sigc::bind<0>(&foo,1)(2,3); //fixes the first argument and calls foo(1,2,3) - * sigc::bind<1>(&foo,1)(2,3); //fixes the second argument and calls foo(2,1,3) - * sigc::bind<2>(&foo,1)(2,3); //fixes the third argument and calls foo(2,3,1) - * // multi argument binding ... - * sigc::bind(&foo,1,2)(3); //fixes the last two arguments and calls foo(3,1,2) - * sigc::bind(&foo,1,2,3)(); //fixes all three arguments and calls foo(1,2,3) - * @endcode - * - * The functor sigc::bind() returns can be passed into - * sigc::signal::connect() directly. - * - * @par Example: - * @code - * sigc::signal some_signal; - * void foo(int); - * some_signal.connect(sigc::bind(&foo,1)); - * @endcode - * - * sigc::bind_return() alters an arbitrary functor by - * fixing its return value to a certain value. - * - * @par Example: - * @code - * void foo(); - * std::cout << sigc::bind_return(&foo, 5)(); // calls foo() and returns 5 - * @endcode - * - * You can bind references to functors by passing the objects through - * the sigc::ref() helper function. - * - * @par Example: - * @code - * int some_int; - * sigc::signal some_signal; - * void foo(int&); - * some_signal.connect(sigc::bind(&foo,sigc::ref(some_int))); - * @endcode - * - * If you bind an object of a sigc::trackable derived type to a functor - * by reference, a slot assigned to the bind adaptor is cleared automatically - * when the object goes out of scope. - * - * @par Example: - * @code - * struct bar : public sigc::trackable {} some_bar; - * sigc::signal some_signal; - * void foo(bar&); - * some_signal.connect(sigc::bind(&foo,sigc::ref(some_bar))); - * // disconnected automatically if some_bar goes out of scope - * @endcode - * - * @ingroup adaptors - */ - -/** Adaptor that binds an argument to the wrapped functor. - * Use the convenience function sigc::bind() to create an instance of sigc::bind_functor. - * - * The following template arguments are used: - * - @e I_location Zero-based position of the argument to fix (@p -1 for the last argument).dnl -FOR(1, CALL_SIZE,[ - * - @e T_type%1 Type of the [ORDINAL(%1)] bound argument.]) - * - @e T_functor Type of the functor to wrap. - * - * @ingroup bind - */ -template -#ifndef DOXYGEN_SHOULD_SKIP_THIS -struct bind_functor; -#else -struct bind_functor {}; -#endif - -FOR(0,eval(CALL_SIZE-1),[[BIND_FUNCTOR_LOCATION(%1)]])dnl - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::bind_functor performs a functor on the - * functor and on the object instances stored in the sigc::bind_functor object. - * - * @ingroup bind - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const bind_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - sigc::visit_each(_A_action, _A_target.bound_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -FOR(1,CALL_SIZE,[[BIND_FUNCTOR_COUNT(%1)]])dnl - -/** Creates an adaptor of type sigc::bind_functor which binds the passed argument to the passed functor. - * The optional template argument @e I_location specifies the zero-based - * position of the argument to be fixed (@p -1 stands for the last argument). - * - * @param _A_func Functor that should be wrapped. - * @param _A_b1 Argument to bind to @e _A_func. - * @return Adaptor that executes @e _A_func with the bound argument on invokation. - * - * @ingroup bind - */ -template -inline bind_functor -bind(const T_functor& _A_func, T_bound1 _A_b1) -{ - return bind_functor - (_A_func, _A_b1); -} - -FOR(1,CALL_SIZE,[[BIND_COUNT(%1)]])dnl - -} /* namespace sigc */ - -#ifdef SIGC_NIL_HAS_BEEN_PUSHED - #undef SIGC_NIL_HAS_BEEN_PUSHED - #pragma pop_macro("nil") -#endif diff --git a/sigc++/adaptors/macros/bind_return.h.m4 b/sigc++/adaptors/macros/bind_return.h.m4 deleted file mode 100644 index 177e7612..00000000 --- a/sigc++/adaptors/macros/bind_return.h.m4 +++ /dev/null @@ -1,126 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([BIND_RETURN_OPERATOR],[dnl - /** Invokes the wrapped functor passing on the arguments.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the functor.]) - * @return The fixed return value. - */ - template - inline typename unwrap_reference::type operator()(LOOP(T_arg%1 _A_a%1, $1)) - { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_a%1, $1)); return ret_value_.invoke(); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - inline typename unwrap_reference::type sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1)) - { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_a%1, $1)); return ret_value_.invoke(); - } - #endif - -]) - -divert(0)dnl -_FIREWALL([ADAPTORS_BIND_RETURN]) -#include -#include - -namespace sigc { - -/** Adaptor that fixes the return value of the wrapped functor. - * Use the convenience function sigc::bind_return() to create an instance of sigc::bind_return_functor. - * - * The following template arguments are used: - * - @e T_return Type of the fixed return value. - * - @e T_functor Type of the functor to wrap. - * - * @ingroup bind - */ -template -struct bind_return_functor : public adapts -{ -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef typename unwrap_reference::type type; }; -#endif - typedef typename unwrap_reference::type result_type; - - /** Invokes the wrapped functor dropping its return value. - * @return The fixed return value. - */ - typename unwrap_reference::type operator()(); - -FOR(1,CALL_SIZE,[[BIND_RETURN_OPERATOR(%1)]])dnl - - /** Constructs a bind_return_functor object that fixes the return value to @p _A_ret_value. - * @param _A_functor Functor to invoke from operator()(). - * @param _A_ret_value Value to return from operator()(). - */ - bind_return_functor(_R_(T_functor) _A_functor, _R_(T_return) _A_ret_value) - : adapts(_A_functor), ret_value_(_A_ret_value) - {} - - /// The fixed return value. - bound_argument ret_value_; // public, so that visit_each() can access it -}; - -template -typename unwrap_reference::type bind_return_functor::operator()() - { this->functor_(); return ret_value_.invoke(); } - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::bind_return_functor performs a functor on the - * functor and on the object instance stored in the sigc::bind_return_functor object. - * - * @ingroup bind - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const bind_return_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.ret_value_); - sigc::visit_each(_A_action, _A_target.functor_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Creates an adaptor of type sigc::bind_return_functor which fixes the return value of the passed functor to the passed argument. - * - * @param _A_functor Functor that should be wrapped. - * @param _A_ret_value Argument to fix the return value of @e _A_functor to. - * @return Adaptor that executes @e _A_functor on invokation and returns @e _A_ret_value. - * - * @ingroup bind - */ -template -inline bind_return_functor -bind_return(const T_functor& _A_functor, T_return _A_ret_value) -{ return bind_return_functor(_A_functor, _A_ret_value); } - -} /* namespace sigc */ diff --git a/sigc++/adaptors/macros/compose.h.m4 b/sigc++/adaptors/macros/compose.h.m4 deleted file mode 100644 index 6cd10dbc..00000000 --- a/sigc++/adaptors/macros/compose.h.m4 +++ /dev/null @@ -1,240 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([COMPOSE1_OPERATOR],[dnl - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_a%1, $1)) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES> - (get_(LOOP(_A_a%1, $1))); - } - -]) - -define([COMPOSE2_OPERATOR],[dnl - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_a%1, $1)) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES, - sigc::deduce_result_t> - (get1_(LOOP(_A_a%1, $1)), get2_(LOOP(_A_a%1,$1))); - } - -]) - -divert(0) -_FIREWALL([ADAPTORS_COMPOSE]) -#include - -namespace sigc { - -/** @defgroup compose compose() - * sigc::compose() combines two or three arbitrary functors. - * On invokation, parameters are passed on to one or two getter functor(s). - * The return value(s) are then passed on to the setter function. - * - * @par Examples: - * @code - * float square_root(float a) { return sqrtf(a); } - * float sum(float a, float b) { return a+b; } - * std::cout << sigc::compose(&square_root, &sum)(9, 16); // calls square_root(sum(3,6)) - * std::cout << sigc::compose(&sum, &square_root, &square_root)(9); // calls sum(square_root(9), square_root(9)) - * @endcode - * - * The functor sigc::compose() returns can be passed directly into - * sigc::signal::connect(). - * - * @par Example: - * @code - * sigc::signal some_signal; - * some_signal.connect(sigc::compose(&square_root, &sum)); - * @endcode - * - * @ingroup adaptors - */ - -/** Adaptor that combines two functors. - * Use the convenience function sigc::compose() to create an instance of sigc::compose1_functor. - * - * The following template arguments are used: - * - @e T_setter Type of the setter functor to wrap. - * - @e T_getter Type of the getter functor to wrap. - * - * @ingroup compose - */ -template -struct compose1_functor : public adapts -{ - typedef typename adapts::adaptor_type adaptor_type; - typedef T_setter setter_type; - typedef T_getter getter_type; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef typename adaptor_type::template deduce_result_type< - sigc::deduce_result_t - >::type type; }; -#endif - typedef typename adaptor_type::result_type result_type; - - result_type - operator()(); - -FOR(1,CALL_SIZE, [[COMPOSE1_OPERATOR(%1)]])dnl - - /** Constructs a compose1_functor object that combines the passed functors. - * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2. - * @param _A_getter Functor to invoke from operator()(). - */ - compose1_functor(const T_setter& _A_setter, const T_getter& _A_getter) - : adapts(_A_setter), get_(_A_getter) - {} - - getter_type get_; // public, so that visit_each() can access it -}; - -template -typename compose1_functor::result_type -compose1_functor::operator()() - { return this->functor_(get_()); } - -/** Adaptor that combines three functors. - * Use the convenience function sigc::compose() to create an instance of sigc::compose2_functor. - * - * The following template arguments are used: - * - @e T_setter Type of the setter functor to wrap. - * - @e T_getter1 Type of the first getter functor to wrap. - * - @e T_getter2 Type of the second getter functor to wrap. - * - * @ingroup compose - */ -template -struct compose2_functor : public adapts -{ - typedef typename adapts::adaptor_type adaptor_type; - typedef T_setter setter_type; - typedef T_getter1 getter1_type; - typedef T_getter2 getter2_type; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef typename adaptor_type::template deduce_result_type< - typename sigc::deduce_result_t, - typename sigc::deduce_result_t - >::type result_type; }; -#endif - typedef typename adaptor_type::result_type result_type; - - result_type - operator()(); - -FOR(1,CALL_SIZE,[[COMPOSE2_OPERATOR(%1)]])dnl - - /** Constructs a compose2_functor object that combines the passed functors. - * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2. - * @param _A_getter1 Functor to invoke from operator()(). - * @param _A_getter2 Functor to invoke from operator()(). - */ - compose2_functor(const T_setter& _A_setter, - const T_getter1& _A_getter1, - const T_getter2& _A_getter2) - : adapts(_A_setter), get1_(_A_getter1), get2_(_A_getter2) - {} - - getter1_type get1_; // public, so that visit_each() can access it - getter2_type get2_; // public, so that visit_each() can access it -}; - -template -typename compose2_functor::result_type -compose2_functor::operator()() - { return this->functor_(get1_(), get2_()); } - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::compose1_functor performs a functor on the - * functors stored in the sigc::compose1_functor object. - * - * @ingroup compose - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const compose1_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - sigc::visit_each(_A_action, _A_target.get_); - } -}; - -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::compose2_functor performs a functor on the - * functors stored in the sigc::compose2_functor object. - * - * @ingroup compose - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const compose2_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - sigc::visit_each(_A_action, _A_target.get1_); - sigc::visit_each(_A_action, _A_target.get2_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Creates an adaptor of type sigc::compose1_functor which combines two functors. - * - * @param _A_setter Functor that receives the return value of the invokation of @e _A_getter. - * @param _A_getter Functor to invoke from operator()(). - * @return Adaptor that executes @e _A_setter with the value returned from invokation of @e _A_getter. - * - * @ingroup compose - */ -template -inline compose1_functor -compose(const T_setter& _A_setter, const T_getter& _A_getter) - { return compose1_functor(_A_setter, _A_getter); } - -/** Creates an adaptor of type sigc::compose2_functor which combines three functors. - * - * @param _A_setter Functor that receives the return values of the invokation of @e _A_getter1 and @e _A_getter2. - * @param _A_getter1 Functor to invoke from operator()(). - * @param _A_getter2 Functor to invoke from operator()(). - * @return Adaptor that executes @e _A_setter with the values return from invokation of @e _A_getter1 and @e _A_getter2. - * - * @ingroup compose - */ -template -inline compose2_functor -compose(const T_setter& _A_setter, const T_getter1& _A_getter1, const T_getter2& _A_getter2) - { return compose2_functor(_A_setter, _A_getter1, _A_getter2); } - -} /* namespace sigc */ diff --git a/sigc++/adaptors/macros/deduce_result_type.h.m4 b/sigc++/adaptors/macros/deduce_result_type.h.m4 deleted file mode 100644 index c7c8fca9..00000000 --- a/sigc++/adaptors/macros/deduce_result_type.h.m4 +++ /dev/null @@ -1,91 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) -include(template.macros.m4) - -divert(0)dnl -/* -*/ -_FIREWALL([ADAPTORS_DEDUCE_RESULT_TYPE]) -#include - -namespace sigc { - -/** A hint to the compiler. - * Functors which have all methods based on templates - * should publicly inherit from this hint and define - * a nested template class @p deduce_result_type that - * can be used to deduce the methods' return types. - * - * adaptor_base inherits from the functor_base hint so - * derived types should also have a result_type defined. - * - * Adaptors don't inherit from this type directly. They use - * use sigc::adapts as a base type instead. sigc::adaptors - * wraps arbitrary functor types as well as function pointers - * and class methods. - * - * @ingroup adaptors - */ -struct adaptor_base : public functor_base {}; - - -/** Deduce the return type of a functor. - * typename deduce_result_type::type - * deduces a functor's result type if @p functor_type inherits from - * sigc::functor_base and defines @p result_type or if @p functor_type - * is actually a (member) function type. Multi-type functors are not - * supported. - * - * sigc++ adaptors use - * typename deduce_result_type::type - * to determine the return type of their templated operator() overloads. - * - * Adaptors in turn define a nested template class @p deduce_result_type - * that is used by template specializations of the global deduce_result_type - * template to correctly deduce the return types of the adaptor's suitable - * template operator() overload. - * - * @ingroup adaptors - */ -template -struct deduce_result_type -{ - //The compiler will choose this method overload if T_functor derives from adaptor_base, - //and if it has its own deduce_result_type member (which has its own ::type member). - template::type> - static - typename U_functor::template deduce_result_type::type - test(); - - //Otherwise, the compiler will choose this fallback method. - template - static - typename functor_trait::result_type - test(); - - using type = decltype (test ()); -}; - -template -using deduce_result_t = typename deduce_result_type::type; - -dnl #ifdef SIGC_CXX_TYPEOF -dnl FOR(0,CALL_SIZE,[[DEDUCE_RESULT_TYPE_TYPEOF(%1,CALL_SIZE)]]) -dnl #endif -dnl -} /* namespace sigc */ diff --git a/sigc++/adaptors/macros/exception_catch.h.m4 b/sigc++/adaptors/macros/exception_catch.h.m4 deleted file mode 100644 index 5f5cd109..00000000 --- a/sigc++/adaptors/macros/exception_catch.h.m4 +++ /dev/null @@ -1,183 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([EXCEPTION_CATCH_OPERATOR],[dnl - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_a%1, $1)) - { - try - { - return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_a%1, $1)); - } - catch (...) - { return catcher_(); } - } - -]) - -divert(0)dnl -_FIREWALL([ADAPTORS_EXCEPTION_CATCH]) -#include - -namespace sigc { - -/* - functor adaptor: exception_catch(functor, catcher) - - usage: - - - Future directions: - The catcher should be told what type of return it needs to - return for multiple type functors, to do this the user - will need to derive from catcher_base. -*/ -/** @defgroup exception_catch exception_catch() - * sigc::exception_catch() catches an exception thrown from within - * the wrapped functor and directs it to a catcher functor. - * This catcher can then rethrow the exception and catch it with the proper type. - * - * Note that the catcher is expected to return the same type - * as the wrapped functor so that normal flow can continue. - * - * Catchers can be cascaded to catch multiple types, because uncaught - * rethrown exceptions proceed to the next catcher adaptor. - * - * @par Examples: - * @code - * struct my_catch - * { - * int operator()() - * { - * try { throw; } - * catch (std::range_error e) // catch what types we know - * { std::cerr << "caught " << e.what() << std::endl; } - * return 1; - * } - * } - * int foo(); // throws std::range_error - * sigc::exception_catch(&foo, my_catch())(); - * @endcode - * - * The functor sigc::exception_catch() returns can be directly passed into - * sigc::signal::connect(). - * - * @par Example: - * @code - * sigc::signal some_signal; - * some_signal.connect(sigc::exception_catch(&foo, my_catch)); - * @endcode - * - * @ingroup adaptors - */ - -template ::result_type> -struct exception_catch_functor : public adapts -{ - typedef typename adapts::adaptor_type adaptor_type; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef typename adaptor_type::template deduce_result_type::type type; }; -#endif - typedef T_return result_type; - - result_type - operator()(); - -FOR(1,CALL_SIZE,[[EXCEPTION_CATCH_OPERATOR(%1)]])dnl - exception_catch_functor(const T_functor& _A_func, - const T_catcher& _A_catcher) - : adapts(_A_func), catcher_(_A_catcher) - {} - - T_catcher catcher_; -}; - -template -typename exception_catch_functor::result_type -exception_catch_functor::operator()() - { - try - { return this->functor_(); } - catch (...) - { return catcher_(); } - } - -// void specialization -template -struct exception_catch_functor : public adapts -{ - typedef void result_type; - typedef typename adapts::adaptor_type adaptor_type; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef typename adaptor_type::template deduce_result_type::type type; }; -#endif - - void - operator()(); - -FOR(1,CALL_SIZE,[[EXCEPTION_CATCH_OPERATOR(%1)]])dnl - exception_catch_functor() {} - exception_catch_functor(const T_functor& _A_func, - const T_catcher& _A_catcher) - : adapts(_A_func), catcher_(_A_catcher) - {} - ~exception_catch_functor() {} - - T_catcher catcher_; -}; - -template -void exception_catch_functor::operator()() - { - try - { this->functor_(); } // I don't understand why void return doesn't work here (Martin) - catch (...) - { this->catcher_(); } - } - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const exception_catch_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - sigc::visit_each(_A_action, _A_target.catcher_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -template -inline exception_catch_functor -exception_catch(const T_functor& _A_func, const T_catcher& _A_catcher) - { return exception_catch_functor(_A_func, _A_catcher); } - -} /* namespace sigc */ diff --git a/sigc++/adaptors/macros/hide.h.m4 b/sigc++/adaptors/macros/hide.h.m4 deleted file mode 100644 index 6bdc199e..00000000 --- a/sigc++/adaptors/macros/hide.h.m4 +++ /dev/null @@ -1,251 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([ORDINAL],[dnl -ifelse($1,0,,$1)ifelse($1,0,[last],$1,1,[st],$1,2,[nd],$1,3,[rd],[th])[]dnl -]) -define([DEDUCE_RESULT_TYPE],[dnl -ifelse(eval($1 < 2),1,[#ifndef DOXYGEN_SHOULD_SKIP_THIS -],)dnl Only for the first two template specializations. ($1 = 0..CALL_SIZE) - template - struct deduce_result_type -ifelse($1,0,[dnl - { typedef typename adaptor_type::template deduce_result_type::type type; }; -],[dnl - { typedef typename adaptor_type::template deduce_result_type::type type; }; -])dnl -ifelse(eval($1 < 2),1,[#endif // DOXYGEN_SHOULD_SKIP_THIS -],)dnl -]) -define([HIDE_OPERATOR],[dnl -ifelse($2,0,,[dnl -ifelse($2,1,[dnl - /** Invokes the wrapped functor ignoring the only argument. - * @param _A_a1 Argument to be ignored. - * @return The return value of the functor invocation. - */ - template - typename deduce_result_type::type - operator()(T_arg1) - { return this->functor_(); } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(T_arg1 _A_a1) - { return this->functor_(); } - #endif - -],$1,0,[dnl - /** Invokes the wrapped functor, ignoring the last argument.dnl -FOR(1, eval($2-1),[ - * @param _A_a%1 Argument to be passed on to the functor.]) - * @param _A_a$2 Argument to be ignored. - * @return The return value of the functor invocation. - */ - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_a%1, eval($2-1)), T_arg$2) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LIST(FOR(1,eval($2-1),[_A_a%1,]))); } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LOOP(T_arg%1 _A_a%1, eval($2-1)), T_arg$2) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LIST(FOR(1,eval($2-1),[_A_a%1,]))); } - #endif - -],[dnl - /** Invokes the wrapped functor, ignoring the ORDINAL($1) argument.dnl -FOR(1, eval($1-1),[ - * @param _A_a%1 Argument to be passed on to the functor.]) - * @param _A_a$1 Argument to be ignored.dnl -FOR(eval($1+1), $2,[ - * @param _A_a%1 Argument to be passed on to the functor.]) - * @return The return value of the functor invocation. - */ - template - typename deduce_result_type::type - operator()(LIST(FOR(1,eval($1-1),[T_arg%1 _A_a%1,]),T_arg$1,FOR(eval($1+1),$2,[T_arg%1 _A_a%1,]))) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LIST(FOR(1,eval($1-1),[_A_a%1,]),FOR(eval($1+1),$2,[_A_a%1,]))); } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LIST(FOR(1,eval($1-1),[T_arg%1 _A_a%1,]),T_arg$1,FOR(eval($1+1),$2,[T_arg%1 _A_a%1,]))) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LIST(FOR(1,eval($1-1),[_A_a%1,]),FOR(eval($1+1),$2,[_A_a%1,]))); } - #endif - -])])dnl -])dnl end HIDE_OPERATOR - -define([HIDE_FUNCTOR],[dnl -ifelse($1,1,[#ifndef DOXYGEN_SHOULD_SKIP_THIS -],)dnl Include only the first two template specializations in the documentation. ($1 = -1..CALL_SIZE-1) -/** Adaptor that adds a dummy parameter to the wrapped functor. - * This template specialization ignores the value of the ORDINAL(eval($1+1)) parameter in operator()(). - * - * @ingroup hide - */ -template -struct hide_functor <$1, T_functor> : public adapts -{ - typedef typename adapts::adaptor_type adaptor_type; - -DEDUCE_RESULT_TYPE(eval($1+1),CALL_SIZE)dnl - typedef typename adaptor_type::result_type result_type; - -FOR(eval($1+1),CALL_SIZE,[[HIDE_OPERATOR(eval($1+1),%1)]])dnl - - /** Constructs a hide_functor object that adds a dummy parameter to the passed functor. - * @param _A_func Functor to invoke from operator()(). - */ - explicit hide_functor(const T_functor& _A_func) - : adapts(_A_func) - {} -}; -ifelse($1,eval(CALL_SIZE-1),[#endif // DOXYGEN_SHOULD_SKIP_THIS -],)dnl Include only the first two template specializations in the documentation. ($1 = -1..CALL_SIZE-1) - -])dnl end HIDE_FUNCTOR - -divert(0)dnl -_FIREWALL([ADAPTORS_HIDE]) -#include - -namespace sigc { - -/** @defgroup hide hide(), hide_return() - * sigc::hide() alters an arbitrary functor in that it adds a parameter - * whose value is ignored on invocation of the returned functor. - * Thus you can discard one argument of a signal. - * - * You may optionally specify the zero-based position of the parameter - * to ignore as a template argument. The default is to ignore the last - * parameter. - * (A value of @p -1 adds a parameter at the end so sigc::hide<-1>() gives the same result as sigc::hide().) - * - * The type of the parameter can optionally be specified if not deduced. - * - * @par Examples: - * @code - * void foo(int, int); - * // single argument hiding ... - * sigc::hide(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2) - * sigc::hide<-1>(&foo)(1,2,3); // same as sigc::hide(&foo)(1,2,3) (calls foo(1,2)) - * sigc::hide<0>(&foo)(1,2,3); // adds a dummy parameter at the beginning and calls foo(2,3) - * sigc::hide<1>(&foo)(1,2,3); // adds a dummy parameter in the middle and calls foo(1,3) - * sigc::hide<2>(&foo)(1,2,3); // adds a dummy parameter at the back and calls foo(1,2) - * @endcode - * - * The functor sigc::hide() returns can be directly passed into - * sigc::signal::connect(). - * - * @par Example: - * @code - * sigc::signal some_signal; - * void foo(); - * some_signal.connect(sigc::hide(&foo)); - * @endcode - * - * sigc::hide() can be nested in order to discard multiple arguments. - * @par Example: - * @code - * // multiple argument hiding ... - * sigc::hide(sigc::hide(&foo))(1,2,3,4); // adds two dummy parameters at the back and calls foo(1,2) - * @endcode - - * sigc::hide_return() alters an arbitrary functor by - * dropping its return value, thus converting it to a void functor. - * - * @ingroup adaptors - */ - -/** Adaptor that adds a dummy parameter to the wrapped functor. - * Use the convenience function sigc::hide() to create an instance of sigc::hide_functor. - * - * The following template arguments are used: - * - @e I_location Zero-based position of the dummy parameter (@p -1 for the last parameter). - * - @e T_type Type of the dummy parameter. - * - @e T_functor Type of the functor to wrap. - * - * @ingroup hide - */ -template -#ifndef DOXYGEN_SHOULD_SKIP_THIS -struct hide_functor; -#else -struct hide_functor {}; -#endif - -FOR(-1,eval(CALL_SIZE-1),[[HIDE_FUNCTOR(%1)]])dnl - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::hide_functor performs a functor on the - * functor stored in the sigc::hide_functor object. - * - * @ingroup hide - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const hide_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor. - * The optional template argument @e I_location specifies the zero-based - * position of the dummy parameter in the returned functor (@p -1 stands for the last parameter). - * - * @param _A_func Functor that should be wrapped. - * @return Adaptor that executes @e _A_func, ignoring the value of the dummy parameter. - * - * @ingroup hide - */ -template -inline hide_functor -hide(const T_functor& _A_func) - { return hide_functor(_A_func); } - -/** Creates an adaptor of type sigc::hide_functor which adds a dummy parameter to the passed functor. - * This overload adds a dummy parameter at the back of the functor's parameter list. - * - * @param _A_func Functor that should be wrapped. - * @return Adaptor that executes @e _A_func, ignoring the value of the last parameter. - * - * @ingroup hide - */ -template -inline hide_functor<-1, T_functor> -hide(const T_functor& _A_func) - { return hide_functor<-1, T_functor> (_A_func); } - -} /* namespace sigc */ diff --git a/sigc++/adaptors/macros/retype.h.m4 b/sigc++/adaptors/macros/retype.h.m4 deleted file mode 100644 index 8267c81e..00000000 --- a/sigc++/adaptors/macros/retype.h.m4 +++ /dev/null @@ -1,222 +0,0 @@ -dnl Copyright 2003, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([RETYPE_OPERATOR],[dnl -ifelse($1,0,[dnl - result_type operator()(); - -],[dnl - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_a%1, $1)) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES, $1)> - (LOOP([[static_cast(_A_a%1)]], $1)); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1)) - { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES, $1)> - (LOOP([[static_cast(_A_a%1)]], $1)); - } - #endif - -])dnl -]) -define([RETYPE_POINTER_FUNCTOR],[dnl -/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor. - * This function template specialization works on sigc::pointer_functor. - * - * @param _A_functor Functor that should be wrapped. - * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on. - * - * @ingroup retype - */ -template -inline retype_functor, LOOP(T_arg%1, $1)) > -retype(const pointer_functor$1& _A_functor) -{ return retype_functor, LOOP(T_arg%1, $1)) > - (_A_functor); } - -]) -define([RETYPE_MEM_FUNCTOR],[dnl -/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor. - * This function template specialization works on sigc::$2[]mem_functor. - * - * @param _A_functor Functor that should be wrapped. - * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on. - * - * @ingroup retype - */ -template -inline retype_functor, LOOP(T_arg%1, $1)) > -retype(const $2[]mem_functor$1& _A_functor) -{ return retype_functor, LOOP(T_arg%1, $1)) > - (_A_functor); } - -]) - -divert(0)dnl -_FIREWALL([ADAPTORS_RETYPE]) -#include -#include -#include -#include - -//TODO: See comment in functor_trait.h. -#if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO) - #define SIGC_NIL_HAS_BEEN_PUSHED 1 - #pragma push_macro("nil") - #undef nil -#endif - -namespace sigc { - -/** @defgroup retype retype(), retype_return() - * sigc::retype() alters a sigc::pointer_functor, a sigc::mem_functor or a sigc::slot - * in that it makes C-style casts to the functor's parameter types - * of all parameters passed through operator()(). - * - * Use this adaptor for inline conversion between numeric or other simple types. - * @par Example: - * @code - * void foo(int); - * sigc::retype(sigc::ptr_fun(&foo))(5.7F); // calls foo(5) - * @endcode - * - * The functor that sigc::retype() returns can be passed directly into - * sigc::signal::connect(). - * - * @par Example: - * @code - * sigc::signal some_signal; - * void foo(int); - * some_signal.connect(sigc::retype(sigc::ptr_fun(&foo))); - * @endcode - * - * This adaptor builds an exception in that it only works on sig::pointer_functor, - * sigc::mem_functor and sigc::slot because it needs sophisticated information about - * the parameter types that cannot be deduced from arbitrary functor types. - * - * sigc::retype_return() alters the return type of an arbitrary functor. - * Like in sigc::retype() a C-style cast is performed. Usage sigc::retype_return() is - * not restricted to libsigc++ functor types but you need to - * specify the new return type as a template parameter. - * - * @par Example: - * @code - * float foo(); - * std::cout << sigc::retype_return(&foo)(); // converts foo's return value to an integer - * @endcode - * - * @ingroup adaptors - */ - -/** Adaptor that performs C-style casts on the parameters passed on to the functor. - * Use the convenience function sigc::retype() to create an instance of retype_functor. - * - * The following template arguments are used: - * - @e T_functor Type of the functor to wrap.dnl -FOR(1, CALL_SIZE,[ - * - @e T_type%1 Type of @e T_functor's %1th argument.]) - * - * @ingroup retype - */ -template -struct retype_functor - : public adapts -{ - typedef typename adapts::adaptor_type adaptor_type; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef typename adaptor_type::template deduce_result_type::type type; }; -#endif - typedef typename adapts::result_type result_type; - -FOR(0,CALL_SIZE,[[RETYPE_OPERATOR(%1)]])dnl - - /** Constructs a retype_functor object that performs C-style casts on the parameters passed on to the functor. - * @param _A_functor Functor to invoke from operator()(). - */ - explicit retype_functor(type_trait_take_t _A_functor) - : adapts(_A_functor) - {} -}; - -template -typename retype_functor::result_type -retype_functor::operator()() - { return this->functor_(); } - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::retype_functor performs a functor on the - * functor stored in the sigc::retype_functor object. - * - * @ingroup retype - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const retype_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters passed on to the functor. - * This function template specialization works on sigc::slot. - * - * @param _A_functor Functor that should be wrapped. - * @return Adaptor that executes @e _A_functor performing C-style casts on the paramters passed on. - * - * @ingroup retype - */ -template -inline retype_functor, LOOP(T_arg%1, CALL_SIZE)) > -retype(const slot& _A_functor) -{ return retype_functor, LOOP(T_arg%1, CALL_SIZE)) > - (_A_functor); } - - -FOR(0,CALL_SIZE,[[RETYPE_POINTER_FUNCTOR(%1)]])dnl - -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[])]])dnl -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[const_])]])dnl -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[volatile_])]])dnl -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[const_volatile_])]])dnl -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[bound_])]])dnl -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[bound_const_])]])dnl -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[bound_volatile_])]])dnl -FOR(0,CALL_SIZE,[[RETYPE_MEM_FUNCTOR(%1,[bound_const_volatile_])]])dnl - -} /* namespace sigc */ - -#ifdef SIGC_NIL_HAS_BEEN_PUSHED - #undef SIGC_NIL_HAS_BEEN_PUSHED - #pragma pop_macro("nil") -#endif diff --git a/sigc++/adaptors/macros/retype_return.h.m4 b/sigc++/adaptors/macros/retype_return.h.m4 deleted file mode 100644 index cf13b986..00000000 --- a/sigc++/adaptors/macros/retype_return.h.m4 +++ /dev/null @@ -1,173 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([RETYPE_RETURN_OPERATOR],[dnl - template - inline T_return operator()(LOOP(T_arg%1 _A_a%1, $1)) - { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_a%1, $1))); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - inline T_return sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1)) - { return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_a%1, $1))); - } - #endif - -]) -define([RETYPE_RETURN_VOID_OPERATOR],[dnl - template - inline void operator()(LOOP(T_arg%1 _A_a%1, $1)) - { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_a%1, $1)); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - inline void sun_forte_workaround(LOOP(T_arg%1 _A_a%1, $1)) - { this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_a%1, $1)); - } - #endif - -]) - -divert(0)dnl -_FIREWALL([ADAPTORS_RETYPE_RETURN]) -#include - -namespace sigc { - -/** Adaptor that performs a C-style cast on the return value of a functor. - * Use the convenience function sigc::retype_return() to create an instance of retype_return_functor. - * - * The following template arguments are used: - * - @e T_return Target type of the C-style cast. - * - @e T_functor Type of the functor to wrap. - * - * @ingroup retype - */ -template -struct retype_return_functor : public adapts -{ -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef T_return type; }; -#endif - typedef T_return result_type; - - T_return operator()(); - -FOR(1,CALL_SIZE,[[RETYPE_RETURN_OPERATOR(%1)]])dnl - retype_return_functor() {} - - /** Constructs a retype_return_functor object that perform a C-style cast on the return value of the passed functor. - * @param _A_functor Functor to invoke from operator()(). - */ - explicit retype_return_functor(_R_(T_functor) _A_functor) - : adapts(_A_functor) - {} -}; - -template -T_return retype_return_functor::operator()() - { return T_return(this->functor_()); } - - -/** Adaptor that performs a C-style cast on the return value of a functor. - * This template specialization is for a void return. It drops the return value of the functor it invokes. - * Use the convenience function sigc::hide_return() to create an instance of sigc::retype_return_functor. - * - * @ingroup retype - */ -/* The void specialization is needed because of explicit cast to T_return. - */ -template -struct retype_return_functor : public adapts -{ -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef void type; }; -#endif - typedef void result_type; - - void operator()(); - -FOR(1,CALL_SIZE,[[RETYPE_RETURN_VOID_OPERATOR(%1)]])dnl - retype_return_functor() {} - retype_return_functor(_R_(T_functor) _A_functor) - : adapts(_A_functor) - {} -}; - -template -void retype_return_functor::operator()() - { this->functor_(); } - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::retype_return_functor performs a functor on the - * functor stored in the sigc::retype_return_functor object. - * - * @ingroup retype - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const retype_return_functor& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the return value of the passed functor. - * The template argument @e T_return specifies the target type of the cast. - * - * @param _A_functor Functor that should be wrapped. - * @return Adaptor that executes @e _A_functor performing a C-style cast on the return value. - * - * @ingroup retype - */ -template -inline retype_return_functor -retype_return(const T_functor& _A_functor) - { return retype_return_functor(_A_functor); } - -/** Creates an adaptor of type sigc::retype_return_functor which drops the return value of the passed functor. - * - * @param _A_functor Functor that should be wrapped. - * @return Adaptor that executes @e _A_functor dropping its return value. - * - * @ingroup hide - */ -template -inline retype_return_functor -hide_return(const T_functor& _A_functor) - { return retype_return_functor(_A_functor); } - -} /* namespace sigc */ diff --git a/sigc++/adaptors/macros/track_obj.h.m4 b/sigc++/adaptors/macros/track_obj.h.m4 deleted file mode 100644 index 9f7d8c2e..00000000 --- a/sigc++/adaptors/macros/track_obj.h.m4 +++ /dev/null @@ -1,225 +0,0 @@ -dnl Copyright 2013, The libsigc++ Development Team -dnl -dnl This file is part of libsigc++. -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library. If not, see . -dnl -divert(-1) - -include(template.macros.m4) - -define([TRACK_OBJECT_OPERATOR],[dnl - /** Invokes the wrapped functor passing on the arguments.dnl -FOR(1, $1,[ - * @param _A_arg%1 Argument to be passed on to the functor.]) - * @return The return value of the functor invocation. - */ - template - typename deduce_result_type::type - operator()(LOOP(T_arg%1 _A_arg%1, $1)) - { - return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_arg%1, $1)); - } - - #ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - template - typename deduce_result_type::type - sun_forte_workaround(LOOP(T_arg%1 _A_arg%1, $1)) - { - return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(_A_arg%1, $1)); - } - #endif - -])dnl end TRACK_OBJECT_OPERATOR - -dnl track_obj_functor[2..CALL_SIZE]. $1 is assumed to be >= 2. -define([TRACK_OBJECT_FUNCTOR],[dnl -/** track_obj_functor$1 wraps a functor and stores $1 references to trackable objects. - * Use the convenience function track_obj() to create an instance of track_obj_functor$1. - * - * @tparam T_functor The type of functor to wrap.dnl -FOR(1,$1,[ - * @tparam T_obj%1 The type of a trackable object.]) - * - * @newin{2,4} - * - * @ingroup track_obj - */ -template -class track_obj_functor$1 : public track_obj_functor1 -{ -public: - /** Constructs a track_obj_functor$1 object that wraps the passed functor and - * stores references to the passed trackable objects. - * @param _A_func Functor.dnl -FOR(1,$1,[ - * @param _A_obj%1 Trackable object.]) - */ - track_obj_functor$1(const T_functor& _A_func, LOOP(const T_obj%1& _A_obj%1, $1)) - : track_obj_functor1(_A_func, _A_obj1)FOR(2,$1,[[, ]obj%1_(_A_obj%1)]) {} - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//protected: - // public, so that visit_each() can access it.dnl -FOR(2,$1,[ - const_limit_reference obj%1_;]) -#endif /* DOXYGEN_SHOULD_SKIP_THIS */ - -}; // end class track_obj_functor$1 - -])dnl end TRACK_OBJECT_FUNCTOR - -define([TRACK_OBJECT_VISIT_EACH],[dnl -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::track_obj_functor$1 performs a functor - * on the functor and on the trackable object instances stored in the - * sigc::track_obj_functor$1 object. - * - * @newin{2,4} - * - * @ingroup track_obj - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const track_obj_functor$1& _A_target) - { - sigc::visit_each(_A_action, _A_target.functor_);dnl -FOR(1,$1,[ - sigc::visit_each(_A_action, _A_target.obj%1_);]) - } -}; - -])dnl end TRACK_OBJECT_VISIT_EACH - -define([TRACK_OBJECT],[dnl -/** Creates an adaptor of type sigc::track_obj_functor$1 which wraps a functor. - * @param _A_func Functor that shall be wrapped.dnl -FOR(1,$1,[ - * @param _A_obj%1 Trackable object.]) - * @return Adaptor that executes _A_func() on invocation. - * - * @newin{2,4} - * - * @ingroup track_obj - */ -template -inline track_obj_functor$1 -track_obj(const T_functor& _A_func, LOOP(const T_obj%1& _A_obj%1, $1)) -{ - return track_obj_functor$1 - (_A_func, LOOP(_A_obj%1, $1)); -} - -])dnl end TRACK_OBJECT - -divert(0)dnl -_FIREWALL([ADAPTORS_TRACK_OBJ]) -#include -#include - -namespace sigc { - -/** @defgroup track_obj track_obj() - * sigc::track_obj() tracks trackable objects, referenced from a functor. - * It can be useful when you assign a C++11 lambda expression or a std::function<> - * to a slot, or connect it to a signal, and the lambda expression or std::function<> - * contains references to sigc::trackable derived objects. - * - * The functor returned by sigc::track_obj() is formally an adaptor, but it does - * not alter the signature, return type or behaviour of the supplied functor. - * Up to CALL_SIZE objects can be tracked. operator()() can have up to CALL_SIZE arguments. - * - * @par Example: - * @code - * struct bar : public sigc::trackable {}; - * sigc::signal some_signal; - * void foo(bar&); - * { - * bar some_bar; - * some_signal.connect([[&some_bar]](){ foo(some_bar); }); - * // NOT disconnected automatically when some_bar goes out of scope - * some_signal.connect(sigc::track_obj([[&some_bar]](){ foo(some_bar); }, some_bar); - * // disconnected automatically when some_bar goes out of scope - * } - * @endcode - * - * @newin{2,4} - * - * @ingroup adaptors - */ - -/** track_obj_functor1 wraps a functor and stores a reference to a trackable object. - * Use the convenience function track_obj() to create an instance of track_obj_functor1. - * - * @tparam T_functor The type of functor to wrap. - * @tparam T_obj1 The type of a trackable object. - * - * @newin{2,4} - * - * @ingroup track_obj - */ -template -class track_obj_functor1 : public adapts -{ -public: - typedef typename adapts::adaptor_type adaptor_type; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS - template - struct deduce_result_type - { typedef typename adaptor_type::template deduce_result_type::type type; }; -#endif - typedef typename adaptor_type::result_type result_type; - - /** Constructs a track_obj_functor1 object that wraps the passed functor and - * stores a reference to the passed trackable object. - * @param _A_func Functor. - * @param _A_obj1 Trackable object. - */ - track_obj_functor1(const T_functor& _A_func, const T_obj1& _A_obj1) - : adapts(_A_func), obj1_(_A_obj1) {} - - /** Invokes the wrapped functor. - * @return The return value of the functor invocation. - */ - result_type operator()() - { return this->functor_(); } - -FOR(1,CALL_SIZE,[[TRACK_OBJECT_OPERATOR(%1)]])dnl - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//protected: - // public, so that visit_each() can access it. - const_limit_reference obj1_; -#endif /* DOXYGEN_SHOULD_SKIP_THIS */ - -}; // end class track_obj_functor1 - -FOR(2,CALL_SIZE,[[TRACK_OBJECT_FUNCTOR(%1)]])dnl - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -FOR(1,CALL_SIZE,[[TRACK_OBJECT_VISIT_EACH(%1)]])dnl -#endif // DOXYGEN_SHOULD_SKIP_THIS - -FOR(1,CALL_SIZE,[[TRACK_OBJECT(%1)]])dnl - -} /* namespace sigc */ diff --git a/sigc++/adaptors/retype.h b/sigc++/adaptors/retype.h new file mode 100644 index 00000000..14e2e3ea --- /dev/null +++ b/sigc++/adaptors/retype.h @@ -0,0 +1,154 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_RETYPE_H +#define SIGC_ADAPTORS_RETYPE_H + +#include +#include +#include +#include + +namespace sigc +{ + +/** @defgroup retype retype(), retype_return() + * sigc::retype() alters a sigc::pointer_functor, a sigc::mem_functor or + * a @ref sigc::slot "sigc::slot" + * in that it makes C-style casts to the functor's parameter types + * of all parameters passed through operator()(). + * + * Use this adaptor for inline conversion between numeric or other simple types. + * @par Example: + * @code + * void foo(int); + * sigc::retype(sigc::ptr_fun(&foo))(5.7F); // calls foo(5) + * @endcode + * + * The functor that sigc::retype() returns can be passed directly into + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" or + * @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()". + * + * @par Example: + * @code + * sigc::signal some_signal; + * void foo(int); + * some_signal.connect(sigc::retype(sigc::ptr_fun(&foo))); + * @endcode + * + * This adaptor builds an exception in that it only works on sigc::pointer_functor, + * sigc::mem_functor and @ref sigc::slot "sigc::slot" + * because it needs sophisticated information about + * the parameter types that cannot be deduced from arbitrary functor types. + * + * sigc::retype_return() alters the return type of an arbitrary functor. + * Like in sigc::retype() a C-style cast is performed. Usage sigc::retype_return() is + * not restricted to libsigc++ functor types but you need to + * specify the new return type as a template parameter. + * + * @par Example: + * @code + * float foo(); + * std::cout << sigc::retype_return(&foo)(); // converts foo's return value to an integer + * @endcode + * + * @ingroup adaptors + */ + +/** Adaptor that performs C-style casts on the parameters passed on to the functor. + * Use the convenience function sigc::retype() to create an instance of retype_functor. + * + * The following template arguments are used: + * - @e T_functor Type of the functor to wrap. + * - @e T_type Types of @e T_functor's arguments. + * + * @ingroup retype + */ +template +struct retype_functor : public adapts +{ + template + decltype(auto) operator()(T_arg... a) + { + return std::invoke(this->functor_, static_cast(a)...); + } + + /** Constructs a retype_functor object that performs C-style casts on the parameters passed on to + * the functor. + * @param functor Functor to invoke from operator()(). + */ + explicit retype_functor(type_trait_take_t functor) : adapts(functor) {} +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::retype_functor performs a functor on the + * functor stored in the sigc::retype_functor object. + * + * @ingroup retype + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const retype_functor& target) + { + sigc::visit_each(action, target.functor_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +// This one takes, for instance, a mem_functor or bound_mem_functor: +/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters + * passed on to the functor. + * + * @param functor Functor that should be wrapped. + * @return Adaptor that executes @e functor performing C-style casts on the paramters passed on. + * + * @ingroup retype + */ +template class T_functor, + typename T_func, + typename... T_arg> +inline decltype(auto) +retype(const T_functor& functor) +{ + return retype_functor, T_arg...>(functor); +} + +// This one takes, for instance, a pointer_functor or slot: +/** Creates an adaptor of type sigc::retype_functor which performs C-style casts on the parameters + * passed on to the functor. + * + * @param functor Functor that should be wrapped. + * @return Adaptor that executes @e functor performing C-style casts on the paramters passed on. + * + * @ingroup retype + */ +template class T_functor, + typename T_return, + typename... T_arg> +inline decltype(auto) +retype(const T_functor& functor) +{ + return retype_functor, T_arg...>(functor); +} + +} /* namespace sigc */ + +#endif /* SIGC_ADAPTORS_RETYPE_H */ diff --git a/sigc++/adaptors/retype_return.h b/sigc++/adaptors/retype_return.h new file mode 100644 index 00000000..bb7159db --- /dev/null +++ b/sigc++/adaptors/retype_return.h @@ -0,0 +1,129 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_RETYPE_RETURN_H +#define SIGC_ADAPTORS_RETYPE_RETURN_H +#include + +namespace sigc +{ + +/** Adaptor that performs a C-style cast on the return value of a functor. + * Use the convenience function sigc::retype_return() to create an instance of + * retype_return_functor. + * + * The following template arguments are used: + * - @e T_return Target type of the C-style cast. + * - @e T_functor Type of the functor to wrap. + * + * @ingroup retype + */ +template +struct retype_return_functor : public adapts +{ + template + inline T_return operator()(T_arg&&... a) + { + return T_return(std::invoke(this->functor_, std::forward(a)...)); + } + + retype_return_functor() = default; + + /** Constructs a retype_return_functor object that perform a C-style cast on the return value of + * the passed functor. + * @param functor Functor to invoke from operator()(). + */ + explicit retype_return_functor(type_trait_take_t functor) : adapts(functor) + { + } +}; + +/** Adaptor that performs a C-style cast on the return value of a functor. + * This template specialization is for a void return. It drops the return value of the functor it + * invokes. + * Use the convenience function sigc::hide_return() to create an instance of + * sigc::retype_return_functor. + * + * @ingroup retype + */ +/* The void specialization is needed because of explicit cast to T_return. + */ +template +struct retype_return_functor : public adapts +{ + template + inline void operator()(T_arg... a) + { + std::invoke(this->functor_, a...); + } + + retype_return_functor() = default; + retype_return_functor(type_trait_take_t functor) : adapts(functor) {} +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::retype_return_functor performs a functor on the + * functor stored in the sigc::retype_return_functor object. + * + * @ingroup retype + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const retype_return_functor& target) + { + sigc::visit_each(action, target.functor_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** Creates an adaptor of type sigc::retype_return_functor which performs a C-style cast on the + * return value of the passed functor. + * The template argument @e T_return specifies the target type of the cast. + * + * @param functor Functor that should be wrapped. + * @return Adaptor that executes @e functor performing a C-style cast on the return value. + * + * @ingroup retype + */ +template +inline retype_return_functor +retype_return(const T_functor& functor) +{ + return retype_return_functor(functor); +} + +/** Creates an adaptor of type sigc::retype_return_functor which drops the return value of the + * passed functor. + * + * @param functor Functor that should be wrapped. + * @return Adaptor that executes @e functor dropping its return value. + * + * @ingroup hide + */ +template +inline retype_return_functor +hide_return(const T_functor& functor) +{ + return retype_return_functor(functor); +} + +} /* namespace sigc */ +#endif /* SIGC_ADAPTORS_RETYPE_RETURN_H */ diff --git a/sigc++/adaptors/track_obj.h b/sigc++/adaptors/track_obj.h new file mode 100644 index 00000000..60890cca --- /dev/null +++ b/sigc++/adaptors/track_obj.h @@ -0,0 +1,172 @@ +/* Copyright 2013 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_ADAPTORS_TRACK_OBJ_H +#define SIGC_ADAPTORS_TRACK_OBJ_H + +#include +#include +#include +#include +#include +#include +#include + +namespace sigc +{ + +/** @defgroup track_obj track_obj(), track_object() + * sigc::track_object() tracks trackable objects, referenced from a functor. + * It can be useful when you assign a C++11 lambda expression or a std::function<> + * to a slot, or connect it to a signal, and the lambda expression or std::function<> + * contains references to sigc::trackable derived objects. + * + * The functor returned by sigc::track_object() is formally an adaptor, but it does + * not alter the signature, return type or behaviour of the supplied functor. + * + * track_obj() is a deprecated alternative to track_object(). + * + * @par Example: + * @code + * struct bar : public sigc::trackable {}; + * sigc::signal some_signal; + * void foo(bar&); + * { + * bar some_bar; + * some_signal.connect([&some_bar](){ foo(some_bar); }); + * // NOT disconnected automatically when some_bar goes out of scope + * some_signal.connect(sigc::track_object([&some_bar](){ foo(some_bar); }, some_bar); + * // disconnected automatically when some_bar goes out of scope + * } + * @endcode + * + * @ingroup adaptors + */ + +/** %track_obj_functor wraps a functor and stores a reference to a trackable object. + * Use the convenience function track_object() to create an instance of %track_obj_functor. + * + * track_obj() is a deprecated alternative to track_object(). + * + * @tparam T_functor The type of functor to wrap. + * @tparam T_obj The types of the trackable objects. + * + * @newin{2,4} + * + * @ingroup track_obj + */ +template +class track_obj_functor : public adapts +{ +public: + /** Constructs a track_obj_functor object that wraps the passed functor and + * stores a reference to the passed trackable objects. + * @param func Functor. + * @param obj Trackable objects. + */ + explicit track_obj_functor(const T_functor& func, const T_obj&... obj) + : adapts(func), obj_(obj...) + { + } + + /** Invokes the wrapped functor passing on the arguments. + * @param arg Arguments to be passed on to the functor. + * @return The return value of the functor invocation. + */ + template + decltype(auto) operator()(T_arg&&... arg) + { + return std::invoke(this->functor_, std::forward(arg)...); + } + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + // protected: + // public, so that visit_each() can access it. + std::tuple...> obj_; +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +}; // end class track_obj_functor + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::track_obj_functor performs a functor + * on the functor and on the trackable object instances stored in the + * sigc::track_obj_functor object. + * + * @newin{2,4} + * + * @ingroup track_obj + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const track_obj_functor& target) + { + sigc::visit_each(action, target.functor_); + + // Call sigc::visit_each(action, element) on each element in the + // target.obj_ tuple: + sigc::internal::tuple_for_each(target.obj_, action); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +#ifndef SIGCXX_DISABLE_DEPRECATED +/** Creates an adaptor of type sigc::track_obj_functor which wraps a functor. + * @param func Functor that shall be wrapped. + * @param obj Trackable objects. + * @return Adaptor that executes func() on invocation. + * + * @newin{2,4} + * @deprecated Use sigc::track_object() instead. + * + * @ingroup track_obj + */ +template +inline decltype(auto) +track_obj(const T_functor& func, const T_obj&... obj) +{ + return track_obj_functor(func, obj...); +} +#endif // SIGCXX_DISABLE_DEPRECATED + +/** Creates an adaptor of type sigc::track_obj_functor which wraps a functor. + * @param func Functor that shall be wrapped. + * @param obj1 Trackable object, derived directly or indirectly from sigc::trackable. + * @param objs Zero or more trackable objects, derived directly or indirectly from sigc::trackable. + * @return Adaptor that executes func() on invocation. + * + * @newin{3,4} + * + * @ingroup track_obj + */ +template +inline decltype(auto) +track_object(const T_functor& func, const T_obj1& obj1, const T_objs&... objs) +{ + static_assert(std::min({ std::is_base_of::value, + std::is_base_of::value... }), + "Each trackable object must be derived from sigc::trackable."); + + return track_obj_functor(func, obj1, objs...); +} + +} /* namespace sigc */ + +#endif /* SIGC_ADAPTORS_TRACK_OBJ_H */ diff --git a/sigc++/adaptors/tuple_visitor_visit_each.h b/sigc++/adaptors/tuple_visitor_visit_each.h new file mode 100644 index 00000000..864b232e --- /dev/null +++ b/sigc++/adaptors/tuple_visitor_visit_each.h @@ -0,0 +1,45 @@ +/* Copyright 2015 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_TUPLE_VISITOR_VISIT_EACH_H +#define SIGC_TUPLE_VISITOR_VISIT_EACH_H + +#include +#include + +namespace sigc +{ + +namespace internal +{ + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +template +struct TupleVisitorVisitEach +{ + template + constexpr static void visit(const T_element& element, T_action&& action) + { + sigc::visit_each(std::forward(action), element); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +} // namespace internal + +} // namespace sigc + +#endif /* SIGC_TUPLE_VISITOR_VISIT_EACH_H */ diff --git a/sigc++/bind.h b/sigc++/bind.h index 4741377c..989a4906 100644 --- a/sigc++/bind.h +++ b/sigc++/bind.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,13 +11,11 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_BIND_HPP_ -#define _SIGC_BIND_HPP_ +#ifndef SIGC_BIND_HPP +#define SIGC_BIND_HPP #include -#endif /* _SIGC_BIND_HPP_ */ +#endif /* SIGC_BIND_HPP */ diff --git a/sigc++/bind_return.h b/sigc++/bind_return.h index fa90c454..82bd3cbf 100644 --- a/sigc++/bind_return.h +++ b/sigc++/bind_return.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,14 +11,11 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_BIND_RETURN_HPP_ -#define _SIGC_BIND_RETURN_HPP_ +#ifndef SIGC_BIND_RETURN_HPP +#define SIGC_BIND_RETURN_HPP #include - -#endif /* _SIGC_BIND_RETURN_HPP_ */ +#endif /* SIGC_BIND_RETURN_HPP */ diff --git a/sigc++/connection.cc b/sigc++/connection.cc index 0d1d52eb..e7c7f2be 100644 --- a/sigc++/connection.cc +++ b/sigc++/connection.cc @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,98 +11,75 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ #include -namespace sigc { +namespace sigc +{ -connection::connection() noexcept -: slot_(nullptr) -{} +connection::connection() noexcept : slot_(nullptr) {} -connection::connection(const connection& c) -: slot_(c.slot_) -{ - //Let the connection forget about the signal handler when the handler object dies: - if (slot_) - slot_->add_destroy_notify_callback(this, ¬ify); -} +connection::connection(slot_base& slot) : slot_(&slot) {} -connection::connection(slot_base& sl) -: slot_(&sl) -{ - //Let the connection forget about the signal handler when the handler object dies: - slot_->add_destroy_notify_callback(this, ¬ify); -} +connection::connection(const connection& c) : slot_(c.slot_) {} -connection& connection::operator=(const connection& c) +connection& +connection::operator=(const connection& src) { - set_slot(c.slot_); + set_slot(src.slot_); return *this; } -connection::~connection() -{ - if (slot_) - slot_->remove_destroy_notify_callback(this); -} +connection::~connection() {} -bool connection::empty() const noexcept +bool +connection::empty() const noexcept { return (!slot_ || slot_->empty()); } -bool connection::connected() const noexcept +bool +connection::connected() const noexcept { return !empty(); } -bool connection::blocked() const noexcept +bool +connection::blocked() const noexcept { return (slot_ ? slot_->blocked() : false); } -bool connection::block(bool should_block) noexcept +bool +connection::block(bool should_block) noexcept { return (slot_ ? slot_->block(should_block) : false); } -bool connection::unblock() noexcept +bool +connection::unblock() noexcept { return (slot_ ? slot_->unblock() : false); } -void connection::disconnect() +void +connection::disconnect() { if (slot_) slot_->disconnect(); // This notifies slot_'s parent. -} +} -connection::operator bool() noexcept +connection::operator bool() const noexcept { return !empty(); } - -void connection::set_slot(slot_base* sl) -{ - if (slot_) - slot_->remove_destroy_notify_callback(this); - - slot_ = sl; - if (slot_) - slot_->add_destroy_notify_callback(this, ¬ify); -} - -void* connection::notify(void* data) +void +connection::set_slot(const sigc::internal::weak_raw_ptr& sl) { - auto self = reinterpret_cast(data); - self->slot_ = nullptr; - return nullptr; + slot_ = sl; } } /* namespace sigc */ diff --git a/sigc++/connection.h b/sigc++/connection.h index 81ad07a2..9d6f1ee7 100644 --- a/sigc++/connection.h +++ b/sigc++/connection.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,28 +11,38 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_CONNECTION_HPP_ -#define _SIGC_CONNECTION_HPP_ + +#ifndef SIGC_CONNECTION_HPP +#define SIGC_CONNECTION_HPP + #include -#include +#include +#include -namespace sigc { +namespace sigc +{ -/** Convinience class for safe disconnection. - * Iterators must not be used beyond the lifetime of the list - * they work on. A connection object can be created from a - * slot list iterator and may safely be used to disconnect - * the referred slot at any time (disconnect()). If the slot - * has already been destroyed, disconnect() does nothing. empty() or +/** Convenience class for safe disconnection. + * + * This may be used to disconnect the referred slot at any time (disconnect()). + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" and + * @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()" + * return a %sigc::connection. + * + * @code + * sigc::connection conn = sig.connect(sigc::mem_fun(a, &A::foo)); + * @endcode + * + * If the slot has already been destroyed, disconnect() does nothing. empty() or * operator bool() can be used to test whether the connection is * still active. The connection can be blocked (block(), unblock()). * - * This is possible because the connection object gets notified - * when the referred slot dies (notify()). + * sigc::connection doesnʼt disconnect the slot automatically upon destruction. + * You do not need to keep the sigc::connection object to retain the connection + * of the slot to the signal. See also @ref sigc::scoped_connection, which does + * disconnect automatically when the connection object is destroyed or replaced. * * @ingroup signal */ @@ -47,30 +56,15 @@ struct SIGC_API connection */ connection(const connection& c); - /** Constructs a connection object from a slot list iterator. - * @param it The slot list iterator to take the slot from. - */ - template - connection(const slot_iterator& it) : slot_(&(*it)) - { if (slot_) slot_->add_destroy_notify_callback(this, ¬ify); } - /** Constructs a connection object from a slot object. - * This is only useful if you create your own slot list. - * @param sl The slot to operate on. + * @param slot The slot to operate on. */ - explicit connection(slot_base& sl); + explicit connection(slot_base& slot); /** Overrides this connection object copying another one. - * @param c The connection object to make a copy from. - */ - connection& operator=(const connection& c); - - /** Overrides this connection object with another slot list iterator. - * @param it The new slot list iterator to take the slot from. + * @param src The connection object to make a copy from. */ - template - connection& operator=(const slot_iterator& it) - { set_slot(&(*it)); return *this; } + connection& operator=(const connection& src); ~connection(); @@ -104,27 +98,20 @@ struct SIGC_API connection /// Disconnects the referred slot. void disconnect(); - //TODO: When we can break API and ABI, make operator bool() const /** Returns whether the connection is still active. * @return @p true if the connection is still active. */ - explicit operator bool() noexcept; - - /** Callback that is executed when the referred slot is destroyed. - * @param data The connection object notified (@p this). - */ - static void* notify(void* data); + explicit operator bool() const noexcept; private: - void set_slot(slot_base* sl); + void set_slot(const sigc::internal::weak_raw_ptr& sl); - /* Referred slot. Set to zero from notify(). - * A value of zero indicates an "empty" connection. + /* Referred slot. Set to nullptr when the referred slot is deleted. + * A value of nullptr indicates an "empty" connection. */ - slot_base* slot_; + sigc::internal::weak_raw_ptr slot_; }; } /* namespace sigc */ - -#endif /* _SIGC_TRACKABLE_HPP_ */ +#endif /* SIGC_CONNECTION_HPP */ diff --git a/sigc++/filelist.am b/sigc++/filelist.am index 9663ea86..ea9155fb 100644 --- a/sigc++/filelist.am +++ b/sigc++/filelist.am @@ -15,56 +15,53 @@ ## You should have received a copy of the GNU Lesser General Public License ## along with this library. If not, see . -# Base (./) -base_m4 = template.macros.m4 signal.h.m4 limit_reference.h.m4 -base_built_cc = -base_built_h = signal.h limit_reference.h - -# Functors (functors/) -functors_m4 = functor_trait.h.m4 slot.h.m4 ptr_fun.h.m4 mem_fun.h.m4 -functors_built_cc = -functors_built_h = functor_trait.h slot.h ptr_fun.h mem_fun.h - -# Adaptors (adaptors/) -adaptors_m4 = deduce_result_type.h.m4 adaptor_trait.h.m4 bind.h.m4 bind_return.h.m4 \ - retype_return.h.m4 hide.h.m4 retype.h.m4 compose.h.m4 exception_catch.h.m4 \ - track_obj.h.m4 -adaptors_built_cc = -adaptors_built_h = deduce_result_type.h adaptor_trait.h bind.h bind_return.h \ - retype_return.h hide.h retype.h compose.h exception_catch.h \ - track_obj.h - -# Lambda (adaptors/lambda) -lambda_m4 = base.h.m4 select.h.m4 lambda.cc.m4 -lambda_built_cc = lambda.cc -lambda_built_h = base.h select.h - -# Combine all the above parts with right directories prefixed -sigc_m4 = $(base_m4:%=macros/%) \ - $(functors_m4:%=functors/macros/%) \ - $(adaptors_m4:%=adaptors/macros/%) \ - $(lambda_m4:%=adaptors/lambda/macros/%) -sigc_built_cc = $(base_built_cc) \ - $(functors_built_cc:%=functors/%) \ - $(adaptors_built_cc:%=adaptors/%) \ - $(lambda_built_cc:%=adaptors/lambda/%) -sigc_built_h = $(base_built_h) \ - $(functors_built_h:%=functors/%) \ - $(adaptors_built_h:%=adaptors/%) \ - $(lambda_built_h:%=adaptors/lambda/%) sigc_public_h = \ bind.h \ bind_return.h \ connection.h \ + limit_reference.h \ + member_method_trait.h \ reference_wrapper.h \ retype_return.h \ + scoped_connection.h \ + signal.h \ signal_base.h \ + signal_connect.h \ slot.h \ trackable.h \ + tuple-utils/tuple_cdr.h \ + tuple-utils/tuple_end.h \ + tuple-utils/tuple_for_each.h \ + tuple-utils/tuple_start.h \ + tuple-utils/tuple_transform_each.h \ type_traits.h \ visit_each.h \ + weak_raw_ptr.h \ + adaptors/adapts.h \ + adaptors/adaptor_base.h \ adaptors/adaptors.h \ + adaptors/adaptor_trait.h \ + adaptors/bind.h \ + adaptors/bind_return.h \ adaptors/bound_argument.h \ + adaptors/compose.h \ + adaptors/exception_catch.h \ + adaptors/hide.h \ + adaptors/retype.h \ + adaptors/track_obj.h \ + adaptors/retype_return.h \ + adaptors/tuple_visitor_visit_each.h \ + functors/functor_trait.h \ functors/functors.h \ + functors/mem_fun.h \ + functors/ptr_fun.h \ + functors/slot.h \ functors/slot_base.h + +sigc_sources_cc = \ + scoped_connection.cc \ + signal_base.cc \ + trackable.cc \ + connection.cc \ + functors/slot_base.cc diff --git a/sigc++/functors/functor_trait.h b/sigc++/functors/functor_trait.h new file mode 100644 index 00000000..e83b36b9 --- /dev/null +++ b/sigc++/functors/functor_trait.h @@ -0,0 +1,89 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_FUNCTORS_FUNCTOR_TRAIT_H +#define SIGC_FUNCTORS_FUNCTOR_TRAIT_H + +#include +#include +#include +#include + +namespace sigc +{ + +/** @defgroup sigcfunctors Functors + * Functors are copyable types that define operator()(). + * + * Types that define operator()() overloads with different return types are referred to + * as multi-type functors. Multi-type functors are only partially supported in libsigc++. + * + * Closures are functors that store all information needed to invoke a callback from operator()(). + * + * Adaptors are functors that alter the signature of a functor's operator()(). + * + * libsigc++ defines numerous functors, closures and adaptors. + * Since libsigc++ is a callback library, most functors are also closures. + * The documentation doesn't distinguish between functors and closures. + * + * The basic functor types libsigc++ provides are created with ptr_fun() and mem_fun() + * and can be converted into slots implicitly. + * The set of adaptors that ships with libsigc++ is documented in the @ref adaptors module. + * + */ + +/** Trait that specifies the appropriate functor type of any callable type. + * Template specializations for function pointers and for class methods are provided. + * + * @tparam T_functor Functor type. + * + * @ingroup sigcfunctors + */ +template +struct functor_trait +{ + using functor_type = T_functor; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// detect the functor version of non-functor types. + +// functor ptr fun: + +template +struct functor_trait +{ + using functor_type = pointer_functor; +}; + +// functor mem fun: + +template +struct functor_trait +{ + using functor_type = mem_functor; +}; + +template +struct functor_trait +{ + using functor_type = mem_functor; +}; + +#endif // DOXYGEN_SHOULD_SKIP_THIS + +} /* namespace sigc */ +#endif /* SIGC_FUNCTORS_FUNCTOR_TRAIT_H */ diff --git a/sigc++/functors/functors.h b/sigc++/functors/functors.h index 3a9619c2..6f08b0a4 100644 --- a/sigc++/functors/functors.h +++ b/sigc++/functors/functors.h @@ -1,6 +1,4 @@ -// -*- c++ -*- -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -13,15 +11,13 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_FUNCTOR_HPP_ -#define _SIGC_FUNCTOR_HPP_ +#ifndef SIGC_FUNCTOR_HPP +#define SIGC_FUNCTOR_HPP #include #include #include -#endif /* _SIGC_FUNCTOR_HPP_ */ +#endif /* SIGC_FUNCTOR_HPP */ diff --git a/sigc++/functors/macros/functor_trait.h.m4 b/sigc++/functors/macros/functor_trait.h.m4 deleted file mode 100644 index 59a9b9b9..00000000 --- a/sigc++/functors/macros/functor_trait.h.m4 +++ /dev/null @@ -1,277 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) -include(template.macros.m4) - -define([FUNCTOR_PTR_FUN],[dnl -template class pointer_functor$1; -template -struct functor_trait -{ - typedef T_return result_type; - typedef pointer_functor$1 functor_type; -}; - -]) -define([FUNCTOR_MEM_FUN],[dnl -template class mem_functor$1; -template class const_mem_functor$1; -template -struct functor_trait -{ - typedef T_return result_type; - typedef mem_functor$1 functor_type; -}; -template -struct functor_trait -{ - typedef T_return result_type; - typedef const_mem_functor$1 functor_type; -}; - -]) - -divert(0)dnl -_FIREWALL([FUNCTORS_FUNCTOR_TRAIT]) -#include -#include - -namespace sigc { - -//TODO: When we can break ABI, replace nil by something else, such as sigc_nil. -// nil is a keyword in Objective C++. When gcc is used for compiling Objective C++ -// programs, nil is defined as a preprocessor macro. -// https://bugzilla.gnome.org/show_bug.cgi?id=695235 -#if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO) - #define SIGC_NIL_HAS_BEEN_PUSHED 1 - #pragma push_macro("nil") - #undef nil -#endif - -/** nil struct type. - * The nil struct type is used as default template argument in the - * unnumbered sigc::signal and sigc::slot templates. - * - * @ingroup signal - * @ingroup slot - */ -#ifndef DOXYGEN_SHOULD_SKIP_THIS -struct nil; -#else -struct nil {}; -#endif - -#ifdef SIGC_NIL_HAS_BEEN_PUSHED - #undef SIGC_NIL_HAS_BEEN_PUSHED - #pragma pop_macro("nil") -#endif - -/** @defgroup sigcfunctors Functors - * Functors are copyable types that define operator()(). - * - * Types that define operator()() overloads with different return types are referred to - * as multi-type functors. Multi-type functors are only partially supported in libsigc++. - * - * Closures are functors that store all information needed to invoke a callback from operator()(). - * - * Adaptors are functors that alter the signature of a functor's operator()(). - * - * libsigc++ defines numerous functors, closures and adaptors. - * Since libsigc++ is a callback library, most functors are also closures. - * The documentation doesn't distinguish between functors and closures. - * - * The basic functor types libsigc++ provides are created with ptr_fun() and mem_fun() - * and can be converted into slots implicitly. - * The set of adaptors that ships with libsigc++ is documented in the @ref adaptors module. - * - * If you want to mix user-defined and third party functors with libsigc++, - * and you want them to be implicitly convertible into slots, libsigc++ must know - * the result type of your functors. There are different ways to achieve that. - * - * - Derive your functors from sigc::functor_base and place - * typedef T_return result_type; in the class definition. - * - Use the macro SIGC_FUNCTOR_TRAIT(T_functor,T_return) in namespace sigc. - * Multi-type functors are only partly supported. - * - For functors not derived from sigc::functor_base, and not specified with - * SIGC_FUNCTOR_TRAIT(), libsigc++ tries to deduce the result type with the - * C++11 decltype() specifier. That attempt usually succeeds if the functor - * has a single operator()(), but it fails if operator()() is overloaded. - * - Use the macro #SIGC_FUNCTORS_HAVE_RESULT_TYPE, if you want libsigc++ to assume - * that result_type is defined in all user-defined or third party functors, - * whose result type can't be deduced in any other way. - * - * If all these ways to deduce the result type fail, void is assumed. - * - * With libsigc++ versions before 2.6, the macro - * #SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE activated the test with - * decltype(). That macro is now unneccesary and deprecated. - */ - -/** A hint to the compiler. - * All functors which define @p result_type should publically inherit from this hint. - * - * @ingroup sigcfunctors - */ -struct functor_base {}; - -/** Helper class, to determine if decltype() can deduce the result type of a functor. - * - * @ingroup sigcfunctors - */ -template -class can_deduce_result_type_with_decltype -{ -private: - struct biggerthanint - { - int memory1; - int memory2; - int memory3; - int memory4; - }; - - static biggerthanint checksize(...); - - // If decltype(&X_functor::operator()) can't be evaluated, this checksize() overload - // is ignored because of the SFINAE rule (Substitution Failure Is Not An Error). - template - static int checksize(X_functor* obj, decltype(&X_functor::operator()) p = nullptr); - -public: - static const bool value -#ifndef DOXYGEN_SHOULD_SKIP_THIS - = sizeof(checksize(static_cast(nullptr))) == sizeof(int) -#endif - ; -}; - - -/** Trait that specifies the return type of any type. - * Template specializations for functors derived from sigc::functor_base, - * for other functors whose result type can be deduced with decltype(), - * for function pointers and for class methods are provided. - * - * @tparam T_functor Functor type. - * @tparam I_derives_functor_base Whether @p T_functor inherits from sigc::functor_base. - * @tparam I_can_use_decltype Whether the result type of @p T_functor can be deduced - * with decltype(). - * - * @ingroup sigcfunctors - */ -template ::value, - bool I_can_use_decltype = can_deduce_result_type_with_decltype::value> -struct functor_trait -{ - typedef void result_type; - typedef T_functor functor_type; -}; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -template -struct functor_trait -{ - typedef typename T_functor::result_type result_type; - typedef T_functor functor_type; -}; - -template -struct functor_trait -{ - typedef typename functor_trait::result_type result_type; - typedef T_functor functor_type; -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -/** Helper macro, if you want to mix user-defined and third party functors with libsigc++. - * - * If you want to mix functors not derived from sigc::functor_base with libsigc++, and - * these functors define @p result_type, use this macro inside namespace sigc like so: - * @code - * namespace sigc { SIGC_FUNCTORS_HAVE_RESULT_TYPE } - * @endcode - * - * @ingroup sigcfunctors - */ -#define SIGC_FUNCTORS_HAVE_RESULT_TYPE \ -template \ -struct functor_trait \ -{ \ - typedef typename T_functor::result_type result_type; \ - typedef T_functor functor_type; \ -}; - -/** Helper macro, if you want to mix user-defined and third party functors with libsigc++. - * - * If you want to mix functors not derived from sigc::functor_base with libsigc++, and - * these functors don't define @p result_type, use this macro inside namespace sigc - * to expose the return type of the functors like so: - * @code - * namespace sigc { - * SIGC_FUNCTOR_TRAIT(first_functor_type, return_type_of_first_functor_type) - * SIGC_FUNCTOR_TRAIT(second_functor_type, return_type_of_second_functor_type) - * ... - * } - * @endcode - * - * @ingroup sigcfunctors - */ -#define SIGC_FUNCTOR_TRAIT(T_functor,T_return) \ -template <> \ -struct functor_trait \ -{ \ - typedef T_return result_type; \ - typedef T_functor functor_type; \ -}; \ -template <> \ -struct functor_trait \ -{ \ - typedef T_return result_type; \ - typedef T_functor functor_type; \ -}; - -#ifndef SIGCXX_DISABLE_DEPRECATED -/** Helper macro, if you want to mix user-defined and third party functors with libsigc++. - * - * If you want to mix functors not derived from sigc::functor_base with libsigc++, - * and your compiler can deduce the result type of the functor with the C++11 - * keyword decltype, use this macro inside namespace sigc like so: - * @code - * namespace sigc { - * SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE - * } - * @endcode - * - * Functors with overloaded operator()() are not supported. - * - * @newin{2,2,11} - * - * @deprecated This macro does nothing. The test it activated in libsigc++ - * versions before 2.6, is now unconditionally activated. - * - * @ingroup sigcfunctors - */ -#define SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE // Empty -#endif // SIGCXX_DISABLE_DEPRECATED - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -// detect the return type and the functor version of non-functor types. -FOR(0,CALL_SIZE,[[FUNCTOR_PTR_FUN(%1)]]) -FOR(0,CALL_SIZE,[[FUNCTOR_MEM_FUN(%1)]]) -#endif // DOXYGEN_SHOULD_SKIP_THIS - -} /* namespace sigc */ diff --git a/sigc++/functors/macros/mem_fun.h.m4 b/sigc++/functors/macros/mem_fun.h.m4 deleted file mode 100644 index 90d1889d..00000000 --- a/sigc++/functors/macros/mem_fun.h.m4 +++ /dev/null @@ -1,281 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([MEMBER_FUNCTOR],[dnl -/** [$2]mem_functor$1 wraps $4 methods with $1 argument(s). - * Use the convenience function mem_fun() to create an instance of [$2]mem_functor$1. - * - * The following template arguments are used:dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of operator()().]) - * - @e T_return The return type of operator()(). - * - @e T_obj The object type. - * - * @ingroup mem_fun - */ -template -class [$2]mem_functor$1 : public functor_base -{ -public: - typedef T_return (T_obj::*function_type)(LOOP(T_arg%1, $1)) $4; - typedef T_return result_type; - - /// Constructs an invalid functor. - [$2]mem_functor$1() : func_ptr_(nullptr) {} - - /** Constructs a [$2]mem_functor$1 object that wraps the passed method. - * @param _A_func Pointer to method will be invoked from operator()(). - */ - explicit [$2]mem_functor$1(function_type _A_func) : func_ptr_(_A_func) {} - - /** Execute the wrapped method operating on the passed instance. - * @param _A_obj Pointer to instance the method should operate on.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the method.]) - * @return The return value of the method invocation. - */ - T_return operator()(LIST($3 T_obj* _A_obj, LOOP(type_trait_take_t _A_a%1, $1))) const - { return (_A_obj->*(this->func_ptr_))(LOOP(_A_a%1, $1)); } - - /** Execute the wrapped method operating on the passed instance. - * @param _A_obj Reference to instance the method should operate on.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the method.]) - * @return The return value of the method invocation. - */ - T_return operator()(LIST($3 T_obj& _A_obj, LOOP(type_trait_take_t _A_a%1, $1))) const - { return (_A_obj.*func_ptr_)(LOOP(_A_a%1, $1)); } - -protected: - function_type func_ptr_; -}; - -]) -define([BOUND_MEMBER_FUNCTOR],[dnl - -/** bound_[$2]mem_functor$1 encapsulates a $4 method with $1 arguments and an object instance. - * Use the convenience function mem_fun() to create an instance of bound_[$2]mem_functor$1. - * - * The following template arguments are used:dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of operator()().]) - * - @e T_return The return type of operator()(). - * - @e T_obj The object type. - * - * @ingroup mem_fun - */ -template -class bound_[$2]mem_functor$1 - : public [$2]mem_functor$1 -{ - typedef [$2]mem_functor$1 base_type_; -public: - typedef typename base_type_::function_type function_type; - - /** Constructs a bound_[$2]mem_functor$1 object that wraps the passed method. - * @param _A_obj Pointer to instance the method will operate on. - * @param _A_func Pointer to method will be invoked from operator()(). - */ - bound_[$2]mem_functor$1($3 T_obj* _A_obj, function_type _A_func) - : base_type_(_A_func), - obj_(*_A_obj) - {} - - /** Constructs a bound_[$2]mem_functor$1 object that wraps the passed method. - * @param _A_obj Reference to instance the method will operate on. - * @param _A_func Pointer to method will be invoked from operator()(). - */ - bound_[$2]mem_functor$1($3 T_obj& _A_obj, function_type _A_func) - : base_type_(_A_func), - obj_(_A_obj) - {} - - /** Execute the wrapped method operating on the stored instance.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the method.]) - * @return The return value of the method invocation. - */ - T_return operator()(LOOP(type_trait_take_t _A_a%1, $1)) const - { return (obj_.invoke().*(this->func_ptr_))(LOOP(_A_a%1, $1)); } - -//protected: - // Reference to stored object instance. - // This is the handler object, such as TheObject in void TheObject::signal_handler(). - [$2]limit_reference obj_; -}; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overload for sigc::bound_[$2]mem_functor performs a functor - * on the object instance stored in the sigc::bound_[$2]mem_functor object. - * - * @ingroup mem_fun - */ -template -struct visitor > -{ - template - static void do_visit_each(const T_action& _A_action, - const bound_[$2]mem_functor$1& _A_target) - { - sigc::visit_each(_A_action, _A_target.obj_); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS -]) - -define([MEM_FUN],[dnl -/** Creates a functor of type sigc::[$3]mem_functor$1 which wraps a $5 method. - * @param _A_func Pointer to method that should be wrapped. - * @return Functor that executes _A_func on invokation. - * - * @ingroup mem_fun - */ -template -inline [$3]mem_functor$1 -mem_fun[]ifelse($2,, $1)(T_return (T_obj::*_A_func)(LOOP(T_arg%1,$1)) $5) -{ return [$3]mem_functor$1(_A_func); } - -]) -define([BOUND_MEM_FUN],[dnl -/** Creates a functor of type sigc::bound_[$3]mem_functor$1 which encapsulates a method and an object instance. - * @param _A_obj Pointer to object instance the functor should operate on. - * @param _A_func Pointer to method that should be wrapped. - * @return Functor that executes @e _A_func on invokation. - * - * @ingroup mem_fun - */ -template -inline bound_[$3]mem_functor$1 -mem_fun[]ifelse($2,, $1)(/*$4*/ T_obj* _A_obj, T_return (T_obj2::*_A_func)(LOOP(T_arg%1,$1)) $5) -{ return bound_[$3]mem_functor$1(_A_obj, _A_func); } - -/** Creates a functor of type sigc::bound_[$3]mem_functor$1 which encapsulates a method and an object instance. - * @param _A_obj Reference to object instance the functor should operate on. - * @param _A_func Pointer to method that should be wrapped. - * @return Functor that executes @e _A_func on invokation. - * - * @ingroup mem_fun - */ -template -inline bound_[$3]mem_functor$1 -mem_fun[]ifelse($2,, $1)(/*$4*/ T_obj& _A_obj, T_return (T_obj2::*_A_func)(LOOP(T_arg%1,$1)) $5) -{ return bound_[$3]mem_functor$1(_A_obj, _A_func); } - -]) - -divert(0) - -// implementation notes: -// - we do not use bind here, because it would introduce -// an extra copy and complicate the header include order if bind is -// to have automatic conversion for member pointers. -_FIREWALL([FUNCTORS_MEM_FUN]) -#include -#include -#include - -namespace sigc { - -/** @defgroup mem_fun mem_fun() - * mem_fun() is used to convert a pointer to a method to a functor. - * - * Optionally, a reference or pointer to an object can be bound to the functor. - * - * @note Only if the object type inherits from sigc::trackable, and the - * functor returned from mem_fun() is assigned to a sigc::slot, is the functor - * automatically cleared when the object goes out of scope! - * - * If the member function pointer is to an overloaded type, you must specify - * the types using template arguments starting with the first argument. - * It is not necessary to supply the return type. - * - * @par Example: - * @code - * struct foo : public sigc::trackable - * { - * void bar(int) {} - * }; - * foo my_foo; - * sigc::slot sl = sigc::mem_fun(my_foo, &foo::bar); - * // Note: f is not a slot. It will not be invalidated when my_foo is deleted. - * auto f = sigc::mem_fun(my_foo, &foo::bar); // Usually not what you want. - * @endcode - * - * For const methods mem_fun() takes a const reference or pointer to an object. - * - * @par Example: - * @code - * struct foo : public sigc::trackable - * { - * void bar(int) const {} - * }; - * const foo my_foo; - * sigc::slot sl = sigc::mem_fun(my_foo, &foo::bar); - * @endcode - * - * Use mem_fun#() if there is an ambiguity as to the number of arguments. - * - * @par Example: - * @code - * struct foo : public sigc::trackable - * { - * void bar(int) {} - * void bar(float) {} - * void bar(int, int) {} - * }; - * foo my_foo; - * sigc::slot sl = sigc::mem_fun1(my_foo, &foo::bar); - * @endcode - * - * @ingroup sigcfunctors - */ - -FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[],[],[])]])dnl -FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[const_],[const],[const])]])dnl -FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[volatile_],[],[volatile])]])dnl -FOR(0,CALL_SIZE,[[MEMBER_FUNCTOR(%1,[const_volatile_],[const],[const volatile])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[],[],[])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[const_],[const],[const])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[volatile_],[],[volatile])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEMBER_FUNCTOR(%1,[const_volatile_],[const],[const volatile])]])dnl - -// numbered -FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[],[],[])]])dnl -FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[const_],[const],[const])]])dnl -FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[volatile_],[],[volatile])]])dnl -FOR(0,CALL_SIZE,[[MEM_FUN(%1,,[const_volatile_],[const],[const volatile])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[],[],[])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[const_],[const],[const])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[volatile_],[],[volatile])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,,[const_volatile_],[const],[const volatile])]])dnl - -// unnumbered -FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[],[],[])]])dnl -FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[const_],[const],[const])]])dnl -FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[volatile_],[],[volatile])]])dnl -FOR(0,CALL_SIZE,[[MEM_FUN(%1,1,[const_volatile_],[const],[const volatile])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[],[],[])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[const_],[const],[const])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[volatile_],[],[volatile])]])dnl -FOR(0,CALL_SIZE,[[BOUND_MEM_FUN(%1,1,[const_volatile_],[const],[const volatile])]])dnl - -} /* namespace sigc */ diff --git a/sigc++/functors/macros/ptr_fun.h.m4 b/sigc++/functors/macros/ptr_fun.h.m4 deleted file mode 100644 index 355b01cb..00000000 --- a/sigc++/functors/macros/ptr_fun.h.m4 +++ /dev/null @@ -1,126 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([POINTER_FUNCTOR],[dnl -/** pointer_functor$1 wraps existing non-member functions with $1 argument(s). - * Use the convenience function ptr_fun() to create an instance of pointer_functor$1. - * - * The following template arguments are used:dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of operator()().]) - * - @e T_return The return type of operator()(). - * - * @ingroup ptr_fun - */ -template -class pointer_functor$1 : public functor_base -{ - typedef T_return (*function_type)(LOOP(T_arg%1, $1)); -protected: - function_type func_ptr_; -public: - typedef T_return result_type; - - /// Constructs an invalid functor. - pointer_functor$1() {} - - /** Constructs a pointer_functor$1 object that wraps an existing function. - * @param _A_func Pointer to function that will be invoked from operator()(). - */ - explicit pointer_functor$1(function_type _A_func): func_ptr_(_A_func) {} - - /** Execute the wrapped function.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the function.]) - * @return The return value of the function invocation. - */ - T_return operator()(LOOP(type_trait_take_t _A_a%1, $1)) const - { return func_ptr_(LOOP(_A_a%1, $1)); } -}; - -]) - -define([PTR_FUN],[dnl -/** Creates a functor of type sigc::pointer_functor$1 which wraps an existing non-member function. - * @param _A_func Pointer to function that should be wrapped. - * @return Functor that executes @e _A_func on invokation. - * - * @ingroup ptr_fun - */ -template -inline pointer_functor$1 -ptr_fun[]ifelse($2,, $1)(T_return (*_A_func)(LOOP(T_arg%1,$1))) -{ return pointer_functor$1(_A_func); } - -]) - -divert(0) -_FIREWALL([FUNCTORS_PTR_FUN]) -#include -#include - -namespace sigc { - -/** @defgroup ptr_fun ptr_fun() - * ptr_fun() is used to convert a pointer to a function to a functor. - * If the function pointer is to an overloaded type, you must specify - * the types using template arguments starting with the first argument. - * It is not necessary to supply the return type. - * - * @par Example: - * @code - * void foo(int) {} - * sigc::slot sl = sigc::ptr_fun(&foo); - * @endcode - * - * Use ptr_fun#() if there is an ambiguity as to the number of arguments. - * - * @par Example: - * @code - * void foo(int) {} // choose this one - * void foo(float) {} - * void foo(int, int) {} - * sigc::slot sl = sigc::ptr_fun1(&foo); - * @endcode - * - * ptr_fun() can also be used to convert a pointer to a static member - * function to a functor, like so: - * - * @par Example: - * @code - * struct foo - * { - * static void bar(int) {} - * }; - * sigc::slot sl = sigc::ptr_fun(&foo::bar); - * @endcode - * - * @ingroup sigcfunctors - */ - -FOR(0,CALL_SIZE,[[POINTER_FUNCTOR(%1)]])dnl - -// numbered ptr_fun -FOR(0,CALL_SIZE,[[PTR_FUN(%1)]])dnl - -// unnumbered ptr_fun -FOR(0,CALL_SIZE,[[PTR_FUN(%1,1)]])dnl - -} /* namespace sigc */ diff --git a/sigc++/functors/macros/slot.h.m4 b/sigc++/functors/macros/slot.h.m4 deleted file mode 100644 index 5c6436ca..00000000 --- a/sigc++/functors/macros/slot.h.m4 +++ /dev/null @@ -1,455 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([SLOT_N],[dnl -/** Converts an arbitrary functor to a unified type which is opaque. - * sigc::slot itself is a functor or to be more precise a closure. It contains - * a single, arbitrary functor (or closure) that is executed in operator()(). - * - * The template arguments determine the function signature of operator()(): - * - @e T_return The return type of operator()().dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of operator()(). The default @p nil means no argument.]) - * - * To use simply assign the desired functor to the slot. If the functor - * is not compatible with the parameter list defined with the template - * arguments compiler errors are triggered. When called the slot - * will invoke the functor with minimal copies. - * block() and unblock() can be used to block the functor's invocation - * from operator()() temporarily. - * - * You should use the more convenient unnumbered sigc::slot template. - * - * @ingroup slot - */ -template -class slot$1 - : public slot_base -{ -public: - typedef T_return result_type; -FOR(1, $1,[ typedef _R_(T_arg%1) arg%1_type_; -]) - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -private: - typedef internal::slot_rep rep_type; -public: - typedef T_return (*call_type)(LIST(rep_type*, LOOP(arg%1_type_, $1))); -#endif - - /** Invoke the contained functor unless slot is in blocking state.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the functor.]) - * @return The return value of the functor invocation. - */ - inline T_return operator()(LOOP(arg%1_type_ _A_a%1, $1)) const - { - if (!empty() && !blocked()) - return (reinterpret_cast(slot_base::rep_->call_))(LIST(slot_base::rep_, LOOP(_A_a%1, $1))); - return T_return(); - } - - inline slot$1() {} - - /** Constructs a slot from an arbitrary functor. - * @param _A_func The desired functor the new slot should be assigned to. - */ - template - slot$1(const T_functor& _A_func) - : slot_base(new internal::typed_slot_rep(_A_func)) - { - //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc. - slot_base::rep_->call_ = internal::slot_call$1::address(); - } - - /** Constructs a slot, copying an existing one. - * @param src The existing slot to copy. - */ - slot$1(const slot$1& src) - : slot_base(src) - {} - - /** Constructs a slot, moving an existing one. - * If @p src is connected to a parent (e.g. a signal), it is copied, not moved. - * @param src The existing slot to move or copy. - */ - slot$1(slot$1&& src) - : slot_base(std::move(src)) - {} - - /** Overrides this slot, making a copy from another slot. - * @param src The slot from which to make a copy. - * @return @p this. - */ - slot$1& operator=(const slot$1& src) - { - slot_base::operator=(src); - return *this; - } - - /** Overrides this slot, making a move from another slot. - * If @p src is connected to a parent (e.g. a signal), it is copied, not moved. - * @param src The slot from which to move or copy. - * @return @p this. - */ - slot$1& operator=(slot$1&& src) - { - slot_base::operator=(std::move(src)); - return *this; - } -}; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * The function overloads for sigc::slot$1 are similar to the function - * overloads for sigc::slot. See the description of those overloads. - * - * @ingroup slot - */ -template -struct visitor> -{ - static void do_visit_each(const internal::limit_derived_target& _A_action, - const slot$1& _A_target) - { - if (_A_target.rep_ && _A_target.rep_->parent_ == nullptr) - _A_target.rep_->set_parent(_A_action.action_.rep_, &internal::slot_rep::notify); - } - - static void do_visit_each(const internal::limit_derived_target& _A_action, - const slot$1& _A_target) - { - if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_) - _A_target.rep_->set_parent(nullptr, nullptr); - } - - template - static void do_visit_each(const T_action& _A_action, - const slot$1& _A_target) - { - _A_action(_A_target); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS - -]) -define([SLOT],[dnl -ifelse($1, $2,[dnl -// Because slot is opaque, visit_each() will not visit its internal members. -// Those members are not reachable by visit_each() after the slot has been -// constructed. But when a slot contains another slot, the outer slot will become -// the parent of the inner slot, with similar results. See the description of -// slot's specialization of the visitor struct. -/** Convenience wrapper for the numbered sigc::slot# templates. - * Slots convert arbitrary functors to unified types which are opaque. - * sigc::slot itself is a functor or to be more precise a closure. It contains - * a single, arbitrary functor (or closure) that is executed in operator()(). - * - * The template arguments determine the function signature of operator()(): - * - @e T_return The return type of operator()().dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of operator()(). The default @p nil means no argument.]) - * - * To use, simply assign the desired functor to the slot. If the functor - * is not compatible with the parameter list defined with the template - * arguments, compiler errors are triggered. When called, the slot - * will invoke the functor with minimal copies. - * block() and unblock() can be used to temporarily block the functor's - * invocation from operator()(). - * - * @par Example: - * @code - * void foo(int) {} - * sigc::slot s = sigc::ptr_fun(&foo); - * s(19); - * @endcode - * - * sigc::slot<> is similar to std::function<>. If you're going to assign the - * resulting functor to a sigc::slot or connect it to a sigc::signal, it's better - * not to use std::function. It would become un unnecessary extra wrapper. - * - * @ingroup slot - */ -template ],[dnl - -/** Convenience wrapper for the numbered sigc::slot$1 template. - * See the base class for useful methods. - * This is the template specialization of the unnumbered sigc::slot - * template for $1 argument(s), specialized for different numbers of arguments - * This is possible because the template has default (nil) template types. -dnl * -dnl * @ingroup slot - */ -template ]) -class slot ifelse($1, $2,,[]) - : public slot$1 -{ -public: - typedef slot$1 parent_type; - - inline slot() {} - - /** Constructs a slot from an arbitrary functor. - * @param _A_func The desired functor the new slot should be assigned to. - */ - template - slot(const T_functor& _A_func) - : parent_type(_A_func) {} - - // Without static_cast parent_type(const T_functor& _A_func) - // is called instead of the copy constructor. - /** Constructs a slot, copying an existing one. - * @param src The existing slot to copy. - */ - slot(const slot& src) - : parent_type(static_cast(src)) {} - - // Without static_cast parent_type(const T_functor& _A_func) - // is called instead of the move constructor. - /** Constructs a slot, moving an existing one. - * If @p src is connected to a parent (e.g. a signal), it is copied, not moved. - * @param src The existing slot to move or copy. - */ - slot(slot&& src) - : parent_type(std::move(static_cast(src))) {} - - /** Overrides this slot, making a copy from another slot. - * @param src The slot from which to make a copy. - * @return @p this. - */ - slot& operator=(const slot& src) - { - parent_type::operator=(src); - return *this; - } - - /** Overrides this slot, making a move from another slot. - * If @p src is connected to a parent (e.g. a signal), it is copied, not moved. - * @param src The slot from which to move or copy. - * @return @p this. - */ - slot& operator=(slot&& src) - { - parent_type::operator=(std::move(src)); - return *this; - } -}; - -ifelse($1, $2,[dnl -#ifndef DOXYGEN_SHOULD_SKIP_THIS -//template specialization of visitor<>::do_visit_each<>(action, functor): -/** Performs a functor on each of the targets of a functor. - * - * There are three function overloads for sigc::slot. - * - * The first two overloads are very specialized. They handle the (probably unusual) - * case when the functor, stored in a slot, contains a slot. They are invoked from - * the constructor, destructor or destroy() method of typed_slot_rep. - * The first overload, called from the constructor of the outer slot, sets - * the outer slot as the parent of the inner slot. The second overload, called from - * the destructor or destroy() of the outer slot, unsets the parent of the inner slot. - * When an object referenced from the inner slot is deleted, the inner slot calls - * its slot_rep::disconnect(), which calls the outer slot's slot_rep::notify(). - * The outer slot is informed just as if one of its directly referenced objects - * had been deleted. Result: The outer slot is disconnected from its parent, - * if any (for instance a sigc::signal). - * See https://bugzilla.gnome.org/show_bug.cgi?id=755003 - * - * The third overload is identical to do_visit_each() in visitor's primary template. - * - * @ingroup slot - */ -template -struct visitor> -{ - static void do_visit_each(const internal::limit_derived_target& _A_action, - const slot& _A_target) - { - if (_A_target.rep_ && _A_target.rep_->parent_ == nullptr) - _A_target.rep_->set_parent(_A_action.action_.rep_, &internal::slot_rep::notify); - } - - static void do_visit_each(const internal::limit_derived_target& _A_action, - const slot& _A_target) - { - if (_A_target.rep_ && _A_target.rep_->parent_ == _A_action.action_.rep_) - _A_target.rep_->set_parent(nullptr, nullptr); - } - - template - static void do_visit_each(const T_action& _A_action, - const slot& _A_target) - { - _A_action(_A_target); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS -]) -]) -define([SLOT_CALL],[dnl -/** Abstracts functor execution. - * call_it() invokes a functor of type @e T_functor with a list of - * parameters whose types are given by the template arguments. - * address() forms a function pointer from call_it(). - * - * The following template arguments are used: - * - @e T_functor The functor type. - * - @e T_return The return type of call_it().dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of call_it().]) - * - */ -template -struct slot_call$1 -{ - /** Invokes a functor of type @p T_functor. - * @param rep slot_rep object that holds a functor of type @p T_functor.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the functor.]) - * @return The return values of the functor invocation. - */ - static T_return call_it(LIST(slot_rep* rep, LOOP(_R_(T_arg%1) a_%1, $1))) - { - typedef typed_slot_rep typed_slot; - typed_slot *typed_rep = static_cast(rep);dnl -ifelse($1,0,[ - return (typed_rep->functor_)(); -],[ - return (typed_rep->functor_).SIGC_WORKAROUND_OPERATOR_PARENTHESES - (LOOP(a_%1, $1)); -])dnl - } - - /** Forms a function pointer from call_it(). - * @return A function pointer formed from call_it(). - */ - static hook address() - { return reinterpret_cast(&call_it); } -}; - -]) - -divert(0)dnl -_FIREWALL([FUNCTORS_SLOT]) -#include -#include -#include -#include - -//TODO: See comment in functor_trait.h. -#if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO) - #define SIGC_NIL_HAS_BEEN_PUSHED 1 - #pragma push_macro("nil") - #undef nil -#endif - -namespace sigc { - -namespace internal { - -/** A typed slot_rep. - * A typed slot_rep holds a functor that can be invoked from - * slot::operator()(). visit_each() is used to visit the functor's - * targets that inherit trackable recursively and register the - * notification callback. Consequently the slot_rep object will be - * notified when some referred object is destroyed or overwritten. - */ -template -struct typed_slot_rep : public slot_rep -{ - typedef typed_slot_rep self; - - /* Use an adaptor type so that arguments can be passed as const references - * through explicit template instantiation from slot_call#::call_it() */ - typedef typename adaptor_trait::adaptor_type adaptor_type; - - /** The functor contained by this slot_rep object. */ - adaptor_type functor_; - - /** Constructs an invalid typed slot_rep object. - * The notification callback is registered using visit_each(). - * @param functor The functor contained by the new slot_rep object. - */ - inline typed_slot_rep(const T_functor& functor) - : slot_rep(nullptr, &destroy, &dup), functor_(functor) - { sigc::visit_each_type(slot_do_bind(this), functor_); } - - inline typed_slot_rep(const typed_slot_rep& cl) - : slot_rep(cl.call_, &destroy, &dup), functor_(cl.functor_) - { sigc::visit_each_type(slot_do_bind(this), functor_); } - - typed_slot_rep& operator=(const typed_slot_rep& src) = delete; - - typed_slot_rep(typed_slot_rep&& src) = delete; - typed_slot_rep& operator=(typed_slot_rep&& src) = delete; - - inline ~typed_slot_rep() - { - call_ = nullptr; - destroy_ = nullptr; - sigc::visit_each_type(slot_do_unbind(this), functor_); - } - - /** Detaches the stored functor from the other referred trackables and destroys it. - * This does not destroy the base slot_rep object. - */ - static void* destroy(void* data) - { - self* self_ = static_cast(reinterpret_cast(data)); - self_->call_ = nullptr; - self_->destroy_ = nullptr; - sigc::visit_each_type(slot_do_unbind(self_), self_->functor_); - self_->functor_.~adaptor_type(); - /* don't call disconnect() here: destroy() is either called - * a) from the parent itself (in which case disconnect() leads to a segfault) or - * b) from a parentless slot (in which case disconnect() does nothing) - */ - return nullptr; - } - - /** Makes a deep copy of the slot_rep object. - * Deep copy means that the notification callback of the new - * slot_rep object is registered in the referred trackables. - * @return A deep copy of the slot_rep object. - */ - static void* dup(void* data) - { - slot_rep* a_rep = reinterpret_cast(data); - return static_cast(new self(*static_cast(a_rep))); - } -}; - - -FOR(0,CALL_SIZE,[[SLOT_CALL(%1)]])dnl -} /* namespace internal */ - - -FOR(0,CALL_SIZE,[[SLOT_N(%1,CALL_SIZE)]]) -SLOT(CALL_SIZE,CALL_SIZE) -FOR(0,eval(CALL_SIZE-1),[[SLOT(%1,CALL_SIZE)]]) - -} /* namespace sigc */ - -#ifdef SIGC_NIL_HAS_BEEN_PUSHED - #undef SIGC_NIL_HAS_BEEN_PUSHED - #pragma pop_macro("nil") -#endif diff --git a/sigc++/functors/mem_fun.h b/sigc++/functors/mem_fun.h new file mode 100644 index 00000000..cdab86e7 --- /dev/null +++ b/sigc++/functors/mem_fun.h @@ -0,0 +1,290 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_FUNCTORS_MEM_FUN_H +#define SIGC_FUNCTORS_MEM_FUN_H +#include +#include +#include +#include +#include + +// implementation notes: +// - we do not use bind here, because it would introduce +// an extra copy and complicate the header include order if bind is +// to have automatic conversion for member pointers. + +namespace sigc +{ + +/** @defgroup mem_fun mem_fun() + * %mem_fun() creates a functor from a pointer to a method. + * + * Optionally, a reference to an object can be bound to the functor. + * + * @note If the object type inherits from sigc::trackable, and the + * functor returned from %mem_fun() is assigned to + * a @ref sigc::slot "sigc::slot", the functor + * will be automatically cleared when the object goes out of scope. Invoking + * that slot will then have no effect and will not try to use the destroyed + * instance. + * + * @par Example: + * @code + * struct foo : public sigc::trackable + * { + * void bar(int) {} + * }; + * foo my_foo; + * sigc::slot sl = sigc::mem_fun(my_foo, &foo::bar); + * // Note: f is not a slot. It will not be invalidated when my_foo is deleted. + * auto f = sigc::mem_fun(my_foo, &foo::bar); // Usually not what you want. + * @endcode + * + * For const methods %mem_fun() takes a const reference or pointer to an object. + * + * @par Example: + * @code + * struct foo : public sigc::trackable + * { + * void bar(int) const {} + * }; + * const foo my_foo; + * sigc::slot sl = sigc::mem_fun(my_foo, &foo::bar); + * @endcode + * + * If the member function pointer is to an overloaded type, you must specify + * the types using template arguments. + * + * @par Example: + * @code + * struct foo : public sigc::trackable + * { + * void bar(int) {} // choose this one + * void bar(float) {} + * void bar(int, int) {} + * }; + * foo my_foo; + * sigc::slot sl = sigc::mem_fun1(my_foo, &foo::bar); + * @endcode + * + * @ingroup sigcfunctors + */ + +template +class mem_functor +{ +public: + using object_type = typename internal::member_method_class::type; + + using function_type = T_func; + + using obj_type_with_modifier = typename std:: + conditional_t::value, const object_type, object_type>; + + /// Constructs an invalid functor. + mem_functor() : func_ptr_(nullptr) {} + + /** Constructs a mem_functor object that wraps the passed method. + * @param func Pointer to method will be invoked from operator()(). + */ + explicit mem_functor(function_type func) : func_ptr_(func) {} + + /** Execute the wrapped method operating on the passed instance. + * @param obj Reference to instance the method should operate on. + * @param a Arguments to be passed on to the method. + * @return The return value of the method invocation. + */ + decltype(auto) operator()(obj_type_with_modifier& obj, type_trait_take_t... a) const + { + return std::invoke(func_ptr_, obj, std::forward>(a)...); + } + +protected: + function_type func_ptr_; +}; + +template +class bound_mem_functor : mem_functor +{ + using base_type = mem_functor; + +public: + using function_type = typename base_type::function_type; + + using object_type = typename base_type::object_type; + + using obj_type_with_modifier = typename std:: + conditional_t::value, const object_type, object_type>; + using T_limit_reference = + typename std::conditional_t::value, + limit_reference, + limit_reference>; + + /** Constructs a bound_mem_functor object that wraps the passed method. + * @param obj Reference to instance the method will operate on. + * @param func Pointer to method will be invoked from operator()(). + */ + bound_mem_functor(obj_type_with_modifier& obj, function_type func) : base_type(func), obj_(obj) {} + + /** Execute the wrapped method operating on the stored instance. + * @param a Arguments to be passed on to the method. + * @return The return value of the method invocation. + */ + decltype(auto) operator()(type_trait_take_t... a) const + { + return std::invoke( + this->func_ptr_, obj_.invoke(), std::forward>(a)...); + } + + // protected: + // Reference to stored object instance. + // This is the handler object, such as TheObject in void TheObject::signal_handler(). + T_limit_reference obj_; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * The function overload for sigc::bound_$1mem_functor performs a functor + * on the object instance stored in the sigc::bound_$1mem_functor object. + * + * @ingroup mem_fun + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, + const bound_mem_functor& target) + { + sigc::visit_each(action, target.obj_); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +/** Creates a functor of type sigc::mem_functor which wraps a method. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) mem_fun(T_return (T_obj::*func)(T_arg...)) +{ + return mem_functor(func); +} + +/** Creates a functor of type sigc::const_mem_functor which wraps a const method. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) +mem_fun(T_return (T_obj::*func)(T_arg...) const) +{ + return mem_functor(func); +} + +/** Creates a functor of type sigc::volatile_mem_functor which wraps a volatile method. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) mem_fun(T_return (T_obj::*func)(T_arg...) volatile) +{ + return mem_functor(func); +} + +/** Creates a functor of type sigc::const_volatile_mem_functor which wraps a const volatile method. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) +mem_fun(T_return (T_obj::*func)(T_arg...) const volatile) +{ + return mem_functor(func); +} + +/** Creates a functor of type sigc::bound_mem_functor which encapsulates a method and an object + * instance. + * @param obj Reference to object instance the functor should operate on. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes @e func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) +mem_fun(/**/ T_obj& obj, T_return (T_obj2::*func)(T_arg...)) +{ + return bound_mem_functor(obj, func); +} + +/** Creates a functor of type sigc::bound_const_mem_functor which encapsulates a method and an + * object instance. + * @param obj Reference to object instance the functor should operate on. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes @e func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) +mem_fun(/*const*/ T_obj& obj, T_return (T_obj2::*func)(T_arg...) const) +{ + return bound_mem_functor(obj, func); +} + +/** Creates a functor of type sigc::bound_volatile_mem_functor which encapsulates a method and an + * object instance. + * @param obj Reference to object instance the functor should operate on. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes @e func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) +mem_fun(/**/ T_obj& obj, T_return (T_obj2::*func)(T_arg...) volatile) +{ + return bound_mem_functor(obj, func); +} + +/** Creates a functor of type sigc::bound_const_volatile_mem_functor which encapsulates a method and + * an object instance. + * @param obj Reference to object instance the functor should operate on. + * @param func Pointer to method that should be wrapped. + * @return Functor that executes @e func on invocation. + * + * @ingroup mem_fun + */ +template +inline decltype(auto) +mem_fun(/*const*/ T_obj& obj, T_return (T_obj2::*func)(T_arg...) const volatile) +{ + return bound_mem_functor(obj, func); +} + +} /* namespace sigc */ +#endif /* SIGC_FUNCTORS_MEM_FUN_H */ diff --git a/sigc++/functors/ptr_fun.h b/sigc++/functors/ptr_fun.h new file mode 100644 index 00000000..d94ed1d7 --- /dev/null +++ b/sigc++/functors/ptr_fun.h @@ -0,0 +1,113 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_FUNCTORS_PTR_FUN_H +#define SIGC_FUNCTORS_PTR_FUN_H +#include +#include +#include + +namespace sigc +{ + +/** @defgroup ptr_fun ptr_fun() + * %ptr_fun() creates a functor from a pointer to a function. + * + * @par Example: + * @code + * void foo(int) {} + * sigc::slot sl = sigc::ptr_fun(&foo); + * @endcode + * + * If the function pointer is to an overloaded type, you must specify + * the types using template arguments. + * + * @par Example: + * @code + * void foo(int) {} // choose this one + * void foo(float) {} + * void foo(int, int) {} + * sigc::slot sl = sigc::ptr_fun(&foo); + * @endcode + * + * %ptr_fun() can also be used to convert a pointer to a static member + * function to a functor, like so: + * + * @par Example: + * @code + * struct foo + * { + * static void bar(int) {} + * }; + * sigc::slot sl = sigc::ptr_fun(&foo::bar); + * @endcode + * + * @ingroup sigcfunctors + */ + +/** pointer_functor wraps existing non-member functions with, or without, arguments. + * Use the convenience function ptr_fun() to create an instance of pointer_functor. + * + * The following template arguments are used: + * - @e T_args... Argument types used in the definition of operator()(). + * - @e T_return The return type of operator()(). + * + * @ingroup ptr_fun + */ +template +class pointer_functor; + +template +class pointer_functor +{ + using function_type = T_return (*)(T_args...); + +protected: + function_type func_ptr_; + +public: + /// Constructs an invalid functor. + pointer_functor() = default; + + /** Constructs a pointer_functor2 object that wraps an existing function. + * @param func Pointer to function that will be invoked from operator()(). + */ + explicit pointer_functor(function_type func) : func_ptr_(func) {} + + /** Execute the wrapped function. + * @param a Arguments to be passed on to the function. + * @return The return value of the function invocation. + */ + T_return operator()(type_trait_take_t... a) const + { + return std::invoke(func_ptr_, std::forward>(a)...); + } +}; + +/** Creates a functor of type sigc::pointer_functor which wraps an existing non-member function. + * @param func Pointer to function that should be wrapped. + * @return Functor that executes @e func on invocation. + * + * @ingroup ptr_fun + */ +template +inline decltype(auto) ptr_fun(T_return (*func)(T_args...)) +{ + return pointer_functor(func); +} + +} /* namespace sigc */ +#endif /* SIGC_FUNCTORS_PTR_FUN_H */ diff --git a/sigc++/functors/slot.cc b/sigc++/functors/slot.cc deleted file mode 100644 index 5b9c92e2..00000000 --- a/sigc++/functors/slot.cc +++ /dev/null @@ -1,25 +0,0 @@ -// -*- c++ -*- -/* - * Copyright 2002, The libsigc++ Development Team - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ -#include - -namespace sigc { - - -} /* namespace sigc */ diff --git a/sigc++/functors/slot.h b/sigc++/functors/slot.h new file mode 100644 index 00000000..ec7f2998 --- /dev/null +++ b/sigc++/functors/slot.h @@ -0,0 +1,329 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_FUNCTORS_SLOT_H +#define SIGC_FUNCTORS_SLOT_H + +#include +#include +#include +#include +#include +#include + +namespace sigc +{ + +namespace internal +{ + +// Conversion between different types of function pointers with +// reinterpret_cast can make gcc8 print a warning. +// https://github.com/libsigcplusplus/libsigcplusplus/issues/1 +// https://github.com/libsigcplusplus/libsigcplusplus/issues/8 +/** Returns the supplied function pointer, cast to a pointer to another function type. + * + * When a single reinterpret_cast between function pointer types causes a + * compiler warning or error, this function may work. + * + * Qualify calls with namespace names: sigc::internal::function_pointer_cast<>(). + * If you don't, indirect calls from another library that also contains a + * function_pointer_cast<>() (perhaps glibmm), can be ambiguous due to ADL + * (argument-dependent lookup). + */ +template +inline T_out +function_pointer_cast(T_in in) +{ + // The double reinterpret_cast suppresses a warning from gcc8 with the + // -Wcast-function-type option. + return reinterpret_cast(reinterpret_cast(in)); +} + +/** A typed slot_rep. + * A typed slot_rep holds a functor that can be invoked from + * slot::operator()(). visit_each() is used to visit the functor's + * targets that inherit trackable recursively and register the + * notification callback. Consequently the slot_rep object will be + * notified when some referred object is destroyed or overwritten. + */ +template +struct typed_slot_rep : public slot_rep +{ +private: + /* Use an adaptor type so that arguments can be passed as const references + * through explicit template instantiation from slot_call#::call_it() */ + using adaptor_type = typename adaptor_trait::adaptor_type; + +public: + /** The functor contained by this slot_rep object. */ + std::unique_ptr functor_; + + /** Constructs an invalid typed slot_rep object. + * The notification callback is registered using visit_each(). + * @param functor The functor contained by the new slot_rep object. + */ + inline explicit typed_slot_rep(const T_functor& functor) + : slot_rep(nullptr), functor_(std::make_unique(functor)) + { + sigc::visit_each_trackable(slot_do_bind(this), *functor_); + } + + inline typed_slot_rep(const typed_slot_rep& src) + : slot_rep(src.call_), functor_(std::make_unique(*src.functor_)) + { + sigc::visit_each_trackable(slot_do_bind(this), *functor_); + } + + typed_slot_rep& operator=(const typed_slot_rep& src) = delete; + + typed_slot_rep(typed_slot_rep&& src) = delete; + typed_slot_rep& operator=(typed_slot_rep&& src) = delete; + + ~typed_slot_rep() override + { + // Call destroy() non-virtually. + // It's unwise to make virtual calls in a constructor or destructor. + typed_slot_rep::destroy(); + } + +private: + /** Detaches the stored functor from the other referred trackables and destroys it. + * This does not destroy the base slot_rep object. + */ + void destroy() override + { + call_ = nullptr; + if (functor_) + { + sigc::visit_each_trackable(slot_do_unbind(this), *functor_); + functor_.reset(nullptr); + } + /* don't call disconnect() here: destroy() is either called + * a) from the parent itself (in which case disconnect() leads to a segfault) or + * b) from a parentless slot (in which case disconnect() does nothing) + */ + } + + /** Makes a deep copy of the slot_rep object. + * Deep copy means that the notification callback of the new + * slot_rep object is registered in the referred trackables. + * @return A deep copy of the slot_rep object. + */ + slot_rep* clone() const override { return new typed_slot_rep(*this); } +}; + +/** Abstracts functor execution. + * call_it() invokes a functor of type @e T_functor with a list of + * parameters whose types are given by the template arguments. + * address() forms a function pointer from call_it(). + * + * The following template arguments are used: + * - @e T_functor The functor type. + * - @e T_return The return type of call_it(). + * - @e T_arg Argument types used in the definition of call_it(). + * + */ +template +struct slot_call +{ + /** Invokes a functor of type @p T_functor. + * @param rep slot_rep object that holds a functor of type @p T_functor. + * @param a Arguments to be passed on to the functor. + * @return The return values of the functor invocation. + */ + static T_return call_it(slot_rep* rep, type_trait_take_t... a_) + { + auto typed_rep = static_cast*>(rep); + return (*typed_rep->functor_) + .template operator()...>( + std::forward>(a_)...); + } + + /** Forms a function pointer from call_it(). + * @return A function pointer formed from call_it(). + */ + static hook address() { return sigc::internal::function_pointer_cast(&call_it); } +}; + +} /* namespace internal */ + +// Because slot is opaque, visit_each() will not visit its internal members. +// Those members are not reachable by visit_each() after the slot has been +// constructed. But when a slot contains another slot, the outer slot will become +// the parent of the inner slot, with similar results. See the description of +// slot's specialization of the visitor struct. + +/** Converts an arbitrary functor to a unified type which is opaque. + * sigc::slot itself is a functor or, to be more precise, a closure. It contains + * a single, arbitrary functor (or closure) that is executed in operator()(). + * + * The template arguments determine the function signature of operator()(): + * - @e T_return The return type of operator()(). + * - @e T_arg Argument types used in the definition of operator()(). + * + * For instance, to declare a slot that returns void and takes two parameters + * of bool and int: + * @code + * sigc::slot some_slot; + * @endcode + * + * To use, simply assign the desired functor to the slot. If the functor + * is not compatible with the parameter list defined with the template + * arguments then compiler errors are triggered. When called, the slot + * will invoke the functor with minimal copies. + * block() and unblock() can be used to block the functor's invocation + * from operator()() temporarily. + * + * @ingroup slot + */ +#ifndef DOXYGEN_SHOULD_SKIP_THIS +template +class slot final { + static_assert(sizeof...(T_arg) < 0, "The slot syntax has been removed. Use the slot syntax."); +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +template +class slot : public slot_base +{ +public: + // TODO: using arg_type_ = type_trait_take_t; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +private: + using rep_type = internal::slot_rep; + +public: + using call_type = T_return (*)(rep_type*, type_trait_take_t...); +#endif + + /** Invoke the contained functor unless slot is in blocking state. + * @param a Arguments to be passed on to the functor. + * @return The return value of the functor invocation. + */ + inline T_return operator()(type_trait_take_t... a) const + { + if (!empty() && !blocked()) + { + return std::invoke(sigc::internal::function_pointer_cast(slot_base::rep_->call_), + slot_base::rep_, + std::forward>(a)...); + } + + return T_return(); + } + + inline slot() = default; + + // If you're tempted to add + // template, int> = 0> + // to the constructor, see https://github.com/libsigcplusplus/libsigcplusplus/issues/79 + // It doesn't work well when sigc::slot is combined with sigc::hide(). + + /** Constructs a slot from an arbitrary functor. + * @param func The desired functor the new slot should be assigned to. + */ + template + slot(const T_functor& func) : slot_base(new internal::typed_slot_rep(func)) + { + // The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc. + slot_base::rep_->call_ = internal::slot_call::address(); + } + + /** Constructs a slot, copying an existing one. + * @param src The existing slot to copy. + */ + slot(const slot& src) = default; + + /** Constructs a slot, moving an existing one. + * If @p src is connected to a parent (e.g. a signal), it is copied, not moved. + * @param src The existing slot to move or copy. + */ + slot(slot&& src) : slot_base(std::move(src)) {} + + /** Overrides this slot, making a copy from another slot. + * @param src The slot from which to make a copy. + * @return @p this. + */ + slot& operator=(const slot& src) = default; + + /** Overrides this slot, making a move from another slot. + * If @p src is connected to a parent (e.g. a signal), it is copied, not moved. + * @param src The slot from which to move or copy. + * @return @p this. + */ + slot& operator=(slot&& src) + { + slot_base::operator=(std::move(src)); + return *this; + } +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +// template specialization of visitor<>::do_visit_each<>(action, functor): +/** Performs a functor on each of the targets of a functor. + * + * There are three function overloads for sigc::slot. + * + * The first two overloads are very specialized. They handle the (probably unusual) + * case when the functor, stored in a slot, contains a slot. They are invoked from + * the constructor, destructor or destroy() method of typed_slot_rep. + * The first overload, called from the constructor of the outer slot, sets + * the outer slot as the parent of the inner slot. The second overload, called from + * the destructor or destroy() of the outer slot, unsets the parent of the inner slot. + * When an object referenced from the inner slot is deleted, the inner slot calls + * its slot_rep::disconnect(), which calls the outer slot's slot_rep::notify_slot_rep_invalidated(). + * The outer slot is informed just as if one of its directly referenced objects + * had been deleted. Result: The outer slot is disconnected from its parent, + * if any (for instance a sigc::signal). + * See https://bugzilla.gnome.org/show_bug.cgi?id=755003 + * + * The third overload is identical to do_visit_each() in visitor's primary template. + * + * @ingroup slot + */ +template +struct visitor> +{ + static void do_visit_each(const internal::limit_trackable_target& action, + const slot& target) + { + if (target.rep_ && target.rep_->parent_ == nullptr) + target.rep_->set_parent( + action.action_.rep_, &internal::slot_rep::notify_slot_rep_invalidated); + } + + static void do_visit_each( + const internal::limit_trackable_target& action, + const slot& target) + { + if (target.rep_ && target.rep_->parent_ == action.action_.rep_) + target.rep_->unset_parent(); + } + + template + static void do_visit_each(const T_action& action, const slot& target) + { + action(target); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +} /* namespace sigc */ + +#endif /* SIGC_FUNCTORS_SLOT_H */ diff --git a/sigc++/functors/slot_base.cc b/sigc++/functors/slot_base.cc index 1b8285ad..afd17940 100644 --- a/sigc++/functors/slot_base.cc +++ b/sigc++/functors/slot_base.cc @@ -1,5 +1,4 @@ -/* - * Copyright 2003, The libsigc++ Development Team +/* Copyright 2003 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,29 +11,21 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ #include +#include namespace { -// Used by slot_rep::notify() and slot_base::operator=(). They must be -// notified, if the slot_rep is deleted when they call disconnect(). -struct destroy_notify_struct +// Used by slot_base::set_parent() when a slot_base without a rep_ is assigned a parent. +class dummy_slot_rep : public sigc::internal::slot_rep { - destroy_notify_struct() noexcept : deleted_(false) { } - - static void* notify(void* data) noexcept - { - auto self_ = reinterpret_cast(data); - self_->deleted_ = true; - return nullptr; - } - - bool deleted_; +public: + dummy_slot_rep() : slot_rep(nullptr) {} + sigc::internal::slot_rep* clone() const override { return new dummy_slot_rep(); } + void destroy() override {} }; } // anonymous namespace @@ -44,18 +35,21 @@ namespace internal { // only MSVC needs this to guarantee that all new/delete are executed from the DLL module #ifdef SIGC_NEW_DELETE_IN_LIBRARY_ONLY -void* slot_rep::operator new(size_t size_) +void* +slot_rep::operator new(size_t size_) { return malloc(size_); } -void slot_rep::operator delete(void* p) +void +slot_rep::operator delete(void* p) { free(p); } #endif -void slot_rep::disconnect() +void +slot_rep::disconnect() { // Invalidate the slot. // _Must_ be done here because parent_ might defer the actual @@ -68,65 +62,55 @@ void slot_rep::disconnect() if (parent_) { auto data_ = parent_; - parent_ = nullptr; // Just a precaution. - (cleanup_)(data_); // Notify the parent (might lead to destruction of this!). + parent_ = nullptr; // Just a precaution. + (cleanup_)(data_); // Notify the parent (might lead to destruction of this!). } } -//static -void* slot_rep::notify(void* data) +// static +void +slot_rep::notify_slot_rep_invalidated(notifiable* data) { - auto self_ = reinterpret_cast(data); + auto self_ = static_cast(data); self_->call_ = nullptr; // Invalidate the slot. - + // Make sure we are notified if disconnect() deletes self_, which is trackable. - destroy_notify_struct notifier; - self_->add_destroy_notify_callback(¬ifier, destroy_notify_struct::notify); + sigc::internal::weak_raw_ptr notifier(self_); self_->disconnect(); // Disconnect the slot (might lead to deletion of self_!). - // If self_ has been deleted, the destructor has called destroy(). - if (!notifier.deleted_) + // If self_ has been deleted, then the weak_raw_ptr will have been invalidated. + if (notifier) { - self_->remove_destroy_notify_callback(¬ifier); - self_->destroy(); // Detach the stored functor from the other referred trackables and destroy it. - // destroy() might lead to deletion of self_. Bug #564005. + // Detach the stored functor from the other referred trackables and destroy it. + // destroy() might lead to deletion of self_. Bug #564005. + self_->destroy(); } - return nullptr; } } // namespace internal - -slot_base::slot_base() noexcept -: rep_(nullptr), - blocked_(false) -{} - -slot_base::slot_base(rep_type* rep) noexcept -: rep_(rep), - blocked_(false) -{} - -slot_base::slot_base(const slot_base& src) -: rep_(nullptr), - blocked_(src.blocked_) + +slot_base::slot_base() noexcept : rep_(nullptr), blocked_(false) {} + +slot_base::slot_base(rep_type* rep) noexcept : rep_(rep), blocked_(false) {} + +slot_base::slot_base(const slot_base& src) : rep_(nullptr), blocked_(src.blocked_) { if (src.rep_) { - //Check call_ so we can ignore invalidated slots. - //Otherwise, destroyed bound reference parameters (whose destruction caused the slot's invalidation) may be used during dup(). - //Note: I'd prefer to check somewhere during dup(). murrayc. + // Check call_ so we can ignore invalidated slots. + // Otherwise, destroyed bound reference parameters (whose destruction caused the slot's + // invalidation) may be used during clone(). + // Note: I'd prefer to check somewhere during clone(). murrayc. if (src.rep_->call_) - rep_ = src.rep_->dup(); + rep_ = src.rep_->clone(); else { - *this = slot_base(); //Return the default invalid slot. + *this = slot_base(); // Return the default invalid slot. } } } -slot_base::slot_base(slot_base&& src) -: rep_(nullptr), - blocked_(src.blocked_) +slot_base::slot_base(slot_base&& src) : rep_(nullptr), blocked_(src.blocked_) { if (src.rep_) { @@ -135,13 +119,13 @@ slot_base::slot_base(slot_base&& src) // src is connected to a parent, e.g. a sigc::signal. // Copy, don't move! See https://bugzilla.gnome.org/show_bug.cgi?id=756484 - //Check call_ so we can ignore invalidated slots. - //Otherwise, destroyed bound reference parameters (whose destruction - //caused the slot's invalidation) may be used during dup(). + // Check call_ so we can ignore invalidated slots. + // Otherwise, destroyed bound reference parameters (whose destruction + // caused the slot's invalidation) may be used during clone(). if (src.rep_->call_) - rep_ = src.rep_->dup(); + rep_ = src.rep_->clone(); else - blocked_ = false; //Return the default invalid slot. + blocked_ = false; // Return the default invalid slot. } else { @@ -149,7 +133,7 @@ slot_base::slot_base(slot_base&& src) src.rep_->notify_callbacks(); rep_ = src.rep_; - //Wipe src: + // Wipe src: src.rep_ = nullptr; src.blocked_ = false; } @@ -158,8 +142,7 @@ slot_base::slot_base(slot_base&& src) slot_base::~slot_base() { - if (rep_) - delete rep_; + delete rep_; } slot_base::operator bool() const noexcept @@ -167,30 +150,30 @@ slot_base::operator bool() const noexcept return rep_ != nullptr; } -void slot_base::delete_rep_with_check() +void +slot_base::delete_rep_with_check() { if (!rep_) return; // Make sure we are notified if disconnect() deletes rep_, which is trackable. - // Compare slot_rep::notify(). - destroy_notify_struct notifier; - rep_->add_destroy_notify_callback(¬ifier, destroy_notify_struct::notify); + // Compare slot_rep::notify_slot_rep_invalidated(). + sigc::internal::weak_raw_ptr notifier(rep_); rep_->disconnect(); // Disconnect the slot (might lead to deletion of rep_!). // If rep_ has been deleted, don't try to delete it again. // If it has been deleted, this slot_base has probably also been deleted, so // don't clear the rep_ pointer. It's the responsibility of the code that // deletes rep_ to either clear the rep_ pointer or delete this slot_base. - if (!notifier.deleted_) + if (notifier) { - rep_->remove_destroy_notify_callback(¬ifier); delete rep_; // Detach the stored functor from the other referred trackables and destroy it. rep_ = nullptr; } } -slot_base& slot_base::operator=(const slot_base& src) +slot_base& +slot_base::operator=(const slot_base& src) { if (src.rep_ == rep_) { @@ -205,7 +188,7 @@ slot_base& slot_base::operator=(const slot_base& src) return *this; } - auto new_rep_ = src.rep_->dup(); + auto new_rep_ = src.rep_->clone(); if (rep_) // Silently exchange the slot_rep. { @@ -219,7 +202,8 @@ slot_base& slot_base::operator=(const slot_base& src) return *this; } -slot_base& slot_base::operator=(slot_base&& src) +slot_base& +slot_base::operator=(slot_base&& src) { if (src.rep_ == rep_) { @@ -239,7 +223,7 @@ slot_base& slot_base::operator=(slot_base&& src) { // src is connected to a parent, e.g. a sigc::signal. // Copy, don't move! See https://bugzilla.gnome.org/show_bug.cgi?id=756484 - new_rep_ = src.rep_->dup(); + new_rep_ = src.rep_->clone(); } else { @@ -247,7 +231,7 @@ slot_base& slot_base::operator=(slot_base&& src) src.rep_->notify_callbacks(); new_rep_ = src.rep_; - //Wipe src: + // Wipe src: src.rep_ = nullptr; src.blocked_ = false; } @@ -261,43 +245,49 @@ slot_base& slot_base::operator=(slot_base&& src) return *this; } -void slot_base::set_parent(void* parent, void* (*cleanup)(void*)) const noexcept +void +slot_base::set_parent(notifiable* parent, notifiable::func_destroy_notify cleanup) const noexcept { - if (rep_) - rep_->set_parent(parent, cleanup); + if (!rep_) + rep_ = new dummy_slot_rep(); + rep_->set_parent(parent, cleanup); } -void slot_base::add_destroy_notify_callback(void* data, func_destroy_notify func) const +void +slot_base::add_destroy_notify_callback(notifiable* data, func_destroy_notify func) const { if (rep_) rep_->add_destroy_notify_callback(data, func); } -void slot_base::remove_destroy_notify_callback(void* data) const +void +slot_base::remove_destroy_notify_callback(notifiable* data) const { if (rep_) rep_->remove_destroy_notify_callback(data); } -bool slot_base::block(bool should_block) noexcept +bool +slot_base::block(bool should_block) noexcept { bool old = blocked_; blocked_ = should_block; return old; } -bool slot_base::unblock() noexcept +bool +slot_base::unblock() noexcept { return block(false); } -void slot_base::disconnect() +void +slot_base::disconnect() { if (rep_) rep_->disconnect(); } - /*bool slot_base::empty() const // having this function not inline is killing performance !!! { if (rep_ && !rep_->call_) @@ -308,4 +298,4 @@ void slot_base::disconnect() return (rep_ == nullptr); }*/ -} //namespace sigc +} // namespace sigc diff --git a/sigc++/functors/slot_base.h b/sigc++/functors/slot_base.h index d9697519..55b62ee2 100644 --- a/sigc++/functors/slot_base.h +++ b/sigc++/functors/slot_base.h @@ -1,5 +1,4 @@ -/* - * Copyright 2003, The libsigc++ Development Team +/* Copyright 2003 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,23 +11,21 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_SLOT_BASE_HPP_ -#define _SIGC_SLOT_BASE_HPP_ +#ifndef SIGC_SLOT_BASE_HPP +#define SIGC_SLOT_BASE_HPP #include #include -#include namespace sigc { -namespace internal { +namespace internal +{ -typedef void* (*hook)(void*); +using hook = void* (*)(void*); /** Internal representation of a slot. * Derivations of this class can be considered as a link @@ -40,20 +37,21 @@ typedef void* (*hook)(void*); * * The base class slot_rep serves the purpose to * - form a common pointer type (slot_rep*), - * - offer the possibility to create duplicates (dup()), - * - offer a notification callback (notify()), + * - offer the possibility to create duplicates (clone()), + * - offer a notification callback (notify_slot_rep_invalidated()), * - implement some of slot_base's interface that depends * on the notification callback, i.e. * -# the possibility to set a single parent with a callback - * (set_parent()) that is executed from notify(), + * (set_parent()) that is executed from notify_slot_rep_invalidated(), * -# a generic function pointer, call_, that is simply - * set to zero in notify() to invalidate the slot. + * set to zero in notify_slot_rep_invalidated() to invalidate the slot. * * slot_rep inherits trackable so that connection objects can * refer to the slot and are notified when the slot is destroyed. */ struct SIGC_API slot_rep : public trackable { +public: slot_rep(const slot_rep& src) = delete; slot_rep& operator=(const slot_rep& src) = delete; @@ -63,38 +61,13 @@ struct SIGC_API slot_rep : public trackable /* NB: Instead of slot_rep we could inherit slot_base from trackable. * However, a simple benchmark seems to indicate that this slows * down dereferencing of slot list iterators. Martin. */ + // TODO: Try this now? murrayc. - /// Callback that invokes the contained functor. - /* This can't be a virtual function since number of arguments - * must be flexible. We use function pointers to slot_call::call_it() - * instead. call_ is set to zero to indicate that the slot is invalid. - */ - hook call_; + inline slot_rep(hook call__) noexcept : call_(call__), cleanup_(nullptr), parent_(nullptr) {} - /// Callback that detaches the slot_rep object from referred trackables and destroys it. - /* This could be a replaced by a virtual dtor. However since this struct is - * crucual for the efficiency of the whole library we want to avoid this. - */ - hook destroy_; + virtual ~slot_rep() {} - /** Callback that makes a deep copy of the slot_rep object. - * @return A deep copy of the slot_rep object. - */ - hook dup_; - - /** Callback of parent_. */ - hook cleanup_; - - /** Parent object whose callback cleanup_ is executed on notification. */ - void* parent_; - - inline slot_rep(hook call__, hook destroy__, hook dup__) noexcept - : call_(call__), destroy_(destroy__), dup_(dup__), cleanup_(nullptr), parent_(nullptr) {} - - inline ~slot_rep() - { destroy(); } - - // only MSVC needs this to guarantee that all new/delete are executed from the DLL module +// only MSVC needs this to guarantee that all new/delete are executed from the DLL module #ifdef SIGC_NEW_DELETE_IN_LIBRARY_ONLY void* operator new(size_t size_); void operator delete(void* p); @@ -102,25 +75,32 @@ struct SIGC_API slot_rep : public trackable /** Destroys the slot_rep object (but doesn't delete it). */ - inline void destroy() - { if (destroy_) (*destroy_)(this); } + virtual void destroy() = 0; /** Makes a deep copy of the slot_rep object. * @return A deep copy of the slot_rep object. */ - inline slot_rep* dup() const - { return reinterpret_cast((*dup_)(const_cast(this))); } + virtual slot_rep* clone() const = 0; /** Set the parent with a callback. * slots have one parent exclusively. * @param parent The new parent. - * @param cleanup The callback to execute from notify(). + * @param cleanup The callback to execute from notify_slot_rep_invalidated(). */ - inline void set_parent(void* parent, hook cleanup) noexcept - { - parent_ = parent; - cleanup_ = cleanup; - } + inline void set_parent(notifiable* parent, notifiable::func_destroy_notify cleanup) noexcept + { + parent_ = parent; + cleanup_ = cleanup; + } + + /** See set_parent(). + * + */ + inline void unset_parent() noexcept + { + parent_ = nullptr; + cleanup_ = nullptr; + } /// Invalidates the slot and executes the parent's cleanup callback. void disconnect(); @@ -132,11 +112,25 @@ struct SIGC_API slot_rep : public trackable * referred object dying. * @param data The slot_rep object that is becoming invalid (@p this). */ - static void* notify(void* data); + static void notify_slot_rep_invalidated(notifiable* data); + +public: + /// Callback that invokes the contained functor. + /* This can't be a virtual function since number of arguments + * must be flexible. We use function pointers to slot_call::call_it() + * instead. call_ is set to zero to indicate that the slot is invalid. + */ + hook call_; + + /** Callback of parent_. */ + notifiable::func_destroy_notify cleanup_; + + /** Parent object whose callback cleanup_ is executed on notification. */ + notifiable* parent_; }; /** Functor used to add a dependency to a trackable. - * Consequently slot_rep::notify() gets executed when the + * Consequently slot_rep::notify_slot_rep_invalidated() gets executed when the * trackable is destroyed or overwritten. */ struct SIGC_API slot_do_bind @@ -147,13 +141,15 @@ struct SIGC_API slot_do_bind /** Construct a slot_do_bind functor. * @param rep The slot_rep object trackables should notify on destruction. */ - inline slot_do_bind(slot_rep* rep) noexcept : rep_(rep) {} + inline explicit slot_do_bind(slot_rep* rep) noexcept : rep_(rep) {} /** Adds a dependency to @p t. * @param t The trackable object to add a callback to. */ - inline void operator()(const trackable* t) const - { t->add_destroy_notify_callback(rep_, &slot_rep::notify); } + inline void operator()(const trackable& t) const + { + t.add_destroy_notify_callback(rep_, &slot_rep::notify_slot_rep_invalidated); + } }; /// Functor used to remove a dependency from a trackable. @@ -165,30 +161,31 @@ struct SIGC_API slot_do_unbind /** Construct a slot_do_unbind functor. * @param rep The slot_rep object trackables don't need to notify on destruction any more. */ - inline slot_do_unbind(slot_rep* rep) noexcept : rep_(rep) {} + inline explicit slot_do_unbind(slot_rep* rep) noexcept : rep_(rep) {} /** Removes a dependency from @p t. * @param t The trackable object to remove the callback from. */ - inline void operator()(const trackable* t) const - { t->remove_destroy_notify_callback(rep_); } + inline void operator()(const trackable& t) const { t.remove_destroy_notify_callback(rep_); } }; -} //namespace internal - +} // namespace internal /** @defgroup slot Slots * Slots are type-safe representations of callback methods and functions. * A slot can be constructed from any function object or function, regardless of * whether it is a global function, a member method, static, or virtual. * - * Use the sigc::mem_fun() and sigc::ptr_fun() template functions to get a sigc::slot, like so: + * @section slots-creating Creating Slots + * + * Use the sigc::mem_fun() or sigc::ptr_fun() template functions to get + * a @ref sigc::slot "sigc::slot", like so: * @code - * sigc::slot sl = sigc::mem_fun(someobj, &SomeClass::somemethod); + * sigc::slot sl = sigc::mem_fun(someobj, &SomeClass::somemethod); * @endcode * or * @code - * sigc::slot sl = sigc::ptr_fun(&somefunction); + * sigc::slot sl = sigc::ptr_fun(&somefunction); * @endcode * or, in gtkmm, * @code @@ -199,16 +196,29 @@ struct SIGC_API slot_do_unbind * * You can also pass slots as method parameters where you might normally pass a function pointer. * + * @section slots-auto-disconnect Member Methods and Automatic Disconnection + * + * See @ref mem_fun "sigc::mem_fun()" about deriving from sigc::trackable to prevent member + * methods from being called after the instance has been destroyed. + * + * @section slots-auto auto + * * sigc::mem_fun() and sigc::ptr_fun() return functors, but those functors are * not slots. * @code - * sigc::slot sl = sigc::mem_fun(someobj, &SomeClass::somemethod); + * sigc::slot sl = sigc::mem_fun(someobj, &SomeClass::somemethod); * @endcode * is not equivalent to * @code * auto sl = sigc::mem_fun(someobj, &SomeClass::somemethod); // Not a slot! * @endcode * + * If you don't explicitly use a @ref sigc::slot "sigc::slot" + * then the slot could call a method on an instance after it has been destroyed + * even if the method is in a class that derives from sigc::trackable. + * + * @section slots-with-lambdas C++ Lambdas + * * A C++11 lambda expression is a functor (function object). It is automatically * wrapped in a slot, if it is connected to a signal. * @code @@ -221,33 +231,31 @@ struct SIGC_API slot_do_unbind * @endcode * * If you connect a C++11 lambda expression or a std::function<> instance to - * a signal or assign it to a slot, - * - With libsigc++ versions before 2.6, if the return type is not void, - you must use the #SIGC_FUNCTORS_DEDUCE_RESULT_TYPE_WITH_DECLTYPE macro, - * - if your functor contains references to sigc::trackable derived objects, - * those objects will not be tracked, unless you also use sigc::track_obj(). + * a signal or assign it to a slot, if your functor contains references to + * sigc::trackable derived objects, those objects will not be tracked, + * unless you also use sigc::track_obj(). * * @ingroup sigcfunctors */ /** Base type for slots. - * slot_base integrates most of the interface of the derived - * sigc::slot templates. slots + * %slot_base integrates most of the interface of the derived + * @ref sigc::slot "sigc::slot" template. Slots * can be connected to signals, be disconnected at some later point * (disconnect()) and temporarily be blocked (block(), unblock()). * The validity of a slot can be tested with empty(). * * The internal representation of a sigc::internal::slot_rep derived - * type is built from slot_base's derivations. set_parent() is used to + * type is built from %slot_base's derivations. set_parent() is used to * register a notification callback that is executed when the slot gets * invalid. add_destroy_notify_callback() is used by connection objects * to add a notification callback that is executed on destruction. * * @ingroup slot */ -class SIGC_API slot_base : public functor_base +class SIGC_API slot_base { - typedef internal::slot_rep rep_type; + using rep_type = internal::slot_rep; // Move operations are not declared noexcept because // 1. they may copy instead of move @@ -284,6 +292,8 @@ class SIGC_API slot_base : public functor_base */ explicit operator bool() const noexcept; + using func_destroy_notify = notifiable::func_destroy_notify; + /** Sets the parent of this slot. * This function is used by signals to register a notification callback. * This notification callback is executed when the slot becomes invalid @@ -291,34 +301,31 @@ class SIGC_API slot_base : public functor_base * @param parent The new parent. * @param cleanup The notification callback. */ - void set_parent(void* parent, void* (*cleanup)(void*)) const noexcept; + void set_parent(notifiable* parent, notifiable::func_destroy_notify cleanup) const noexcept; - typedef trackable::func_destroy_notify func_destroy_notify; - /** Add a callback that is executed (notified) when the slot is detroyed. + /** Add a callback that is executed (notified) when the slot is destroyed. * This function is used internally by connection objects. * @param data Passed into func upon notification. * @param func Callback executed upon destruction of the object. */ - void add_destroy_notify_callback(void* data, func_destroy_notify func) const; + void add_destroy_notify_callback(notifiable* data, notifiable::func_destroy_notify func) const; /** Remove a callback previously installed with add_destroy_notify_callback(). * The callback is not executed. * @param data Parameter passed into previous call to add_destroy_notify_callback(). */ - void remove_destroy_notify_callback(void* data) const; + void remove_destroy_notify_callback(notifiable* data) const; /** Returns whether the slot is invalid. * @return @p true if the slot is invalid (empty). */ - inline bool empty() const noexcept - { return (!rep_ || !rep_->call_); } + inline bool empty() const noexcept { return (!rep_ || !rep_->call_); } /** Returns whether the slot is blocked. * @return @p true if the slot is blocked. */ - inline bool blocked() const noexcept - { return blocked_; } - + inline bool blocked() const noexcept { return blocked_; } + /** Sets the blocking state. * If @e should_block is @p true then the blocking state is set. * Subsequent calls to slot::operator()() don't invoke the functor @@ -339,9 +346,10 @@ class SIGC_API slot_base : public functor_base */ void disconnect(); -//The Tru64 and Solaris Forte 5.5 compilers needs this operator=() to be public. I'm not sure why, or why it needs to be protected usually. murrayc. -//See bug #168265. -//protected: + // The Tru64 and Solaris Forte 5.5 compilers needs this operator=() to be public. I'm not sure + // why, or why it needs to be protected usually. murrayc. + // See bug #168265. + // protected: /** Overrides this slot, making a copy from another slot. * @param src The slot from which to make a copy. * @return @p this. @@ -357,7 +365,7 @@ class SIGC_API slot_base : public functor_base public: // public to avoid template friend declarations /** Typed slot_rep object that contains a functor. */ - mutable rep_type *rep_; + mutable rep_type* rep_; /** Indicates whether the slot is blocked. */ bool blocked_; @@ -366,7 +374,6 @@ class SIGC_API slot_base : public functor_base void delete_rep_with_check(); }; -} //namespace sigc - -#endif //_SIGC_SLOT_BASE_HPP_ +} // namespace sigc +#endif // SIGC_SLOT_BASE_HPP diff --git a/sigc++/limit_reference.h b/sigc++/limit_reference.h new file mode 100644 index 00000000..f55330d8 --- /dev/null +++ b/sigc++/limit_reference.h @@ -0,0 +1,148 @@ +/* Copyright 2005 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_LIMIT_REFERENCE_H +#define SIGC_LIMIT_REFERENCE_H + +#include +#include +#include + +namespace sigc +{ + +/** A limit_reference object stores a reference (Foo&), but makes sure that, + * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the + * sigc::trackable reference instead of the derived reference. This avoids use of + * a reference to the derived type when the derived destructor has run. That can be + * a problem when using virtual inheritance. + * + * If Foo inherits from trackable then both the derived reference and the + * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable + * reference without doing an implicit conversion. To retrieve the derived reference + * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable + * reference (so that you can call visit_each() on it), you use visit(). + * + * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the + * derived reference. + * + * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values, + * and, with mem_fun(), the reference to the handling object. + * + * - @e T_type The type of the reference. + */ +template>::value> +class limit_reference +{ +public: + using reference_type = typename std::remove_volatile_t; + + limit_reference() = delete; + + /** Constructor. + * @param target The reference to limit. + */ + explicit limit_reference(reference_type& target) : visited(target) {} + + limit_reference(const limit_reference& src) = default; + limit_reference& operator=(const limit_reference& src) = default; + + limit_reference(limit_reference&& src) = default; + limit_reference& operator=(limit_reference&& src) = default; + + /** Retrieve the entity to visit for visit_each(). + * Depending on the template specialization, this is either a derived reference, or + * sigc::trackable& if T_type derives from sigc::trackable. + * @return The reference. + */ + inline const reference_type& visit() const { return visited; } + + /** Retrieve the reference. + * This is always a reference to the derived instance. + * @return The reference. + */ + inline T_type& invoke() const { return visited; } + +private: + /** The reference. + */ + reference_type& visited; +}; + +/** limit_reference object for a class that derives from trackable. + * - @e T_type The type of the reference. + */ +template +class limit_reference +{ +public: + using reference_type = typename std::remove_volatile_t; + + /** Constructor. + * @param target The reference to limit. + */ + limit_reference(reference_type& target) : visited(target), invoked(target) {} + + /** Retrieve the entity to visit for visit_each(). + * Depending on the template specialization, this is either a derived reference, or + * sigc::trackable& if T_type derives from sigc::trackable. + * @return The reference. + */ + inline const trackable& visit() const { return visited; } + + /** Retrieve the reference. + * This is always a reference to the derived instance. + * @return The reference. + */ + inline T_type& invoke() const { return invoked; } + +private: + using trackable_type = + typename std::conditional_t::value, const trackable, trackable>; + + /** The trackable reference. + */ + trackable_type& visited; + + /** The reference. + */ + reference_type& invoked; +}; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS +/** Implementation of visitor specialized for the $1limit_reference + * class, to call visit_each() on the entity returned by the $1limit_reference's + * visit() method. + * @tparam T_type The type of the reference + * @tparam T_action The type of functor to invoke. + * @param action The functor to invoke. + * @param target The visited instance. + */ +template +struct visitor> +{ + template + static void do_visit_each(const T_action& action, const limit_reference& target) + { + sigc::visit_each(action, target.visit()); + } +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +} /* namespace sigc */ + +#endif /* SIGC_LIMIT_REFERENCE_H */ diff --git a/sigc++/macros/limit_reference.h.m4 b/sigc++/macros/limit_reference.h.m4 deleted file mode 100644 index 679a86ca..00000000 --- a/sigc++/macros/limit_reference.h.m4 +++ /dev/null @@ -1,158 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([LIMIT_REFERENCE],[dnl -/** A [$1]limit_reference object stores a reference (Foo&), but make sure that, - * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the - * sigc::trackable reference instead of the derived reference. This avoids use of - * a reference to the derived type when the derived destructor has run. That can be - * a problem when using virtual inheritance. - * - * If Foo inherits from trackable then both the derived reference and the - * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable - * reference without doing an implicit conversion. To retrieve the derived reference - * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable - * reference (so that you can call visit_each() on it), you use visit(). - * - * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the - * derived reference. - * - * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values, - * and, with mem_fun(), the reference to the handling object. - * - * - @e T_type The type of the reference. - */ -template ::value> -class [$1]limit_reference -{ -public: - /** Constructor. - * @param _A_target The reference to limit. - */ - [$1]limit_reference([$2]T_type& _A_target) - : visited(_A_target) - {} - - /** Retrieve the entity to visit for visit_each(). - * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable. - * @return The reference. - */ - inline const T_type& visit() const - { return visited; } - - /** Retrieve the reference. - * This is always a reference to the derived instance. - * @return The reference. - */ - inline [$3]T_type& invoke() const - { return visited; } - -private: - /** The reference. - */ - [$2]T_type& visited; -}; - -/** [$1]limit_reference object for a class that derives from trackable. - * - @e T_type The type of the reference. - */ -template -class [$1]limit_reference -{ -public: - /** Constructor. - * @param _A_target The reference to limit. - */ - [$1]limit_reference([$2]T_type& _A_target) - : visited(_A_target), - invoked(_A_target) - {} - - /** Retrieve the entity to visit for visit_each(). - * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable. - * @return The reference. - */ - inline const trackable& visit() const - { return visited; } - - /** Retrieve the reference. - * This is always a reference to the derived instance. - * @return The reference. - */ - inline [$3]T_type& invoke() const - { return invoked; } - -private: - /** The trackable reference. - */ - [$2]trackable& visited; - - /** The reference. - */ - [$2]T_type& invoked; -}; - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -/** Implementation of visitor specialized for the [$1]limit_reference - * class, to call visit_each() on the entity returned by the [$1]limit_reference's - * visit() method. - * @tparam T_type The type of the reference. - * @tparam T_action The type of functor to invoke. - * @param _A_action The functor to invoke. - * @param _A_target The visited instance. - */ -template -struct visitor<[$1]limit_reference > -{ - template - static void do_visit_each(const T_action& _A_action, - const [$1]limit_reference& _A_target) - { - sigc::visit_each(_A_action, _A_target.visit()); - } -}; -#endif // DOXYGEN_SHOULD_SKIP_THIS -]) - -divert(0) - -_FIREWALL([LIMIT_REFERENCE]) - -#include -#include -#include - -namespace sigc { - -LIMIT_REFERENCE([],[],[])dnl - - -LIMIT_REFERENCE([const_],[const ],[const ])dnl - - -LIMIT_REFERENCE([volatile_],[],[volatile ])dnl - - -LIMIT_REFERENCE([const_volatile_],[const ],[const volatile ])dnl - -} /* namespace sigc */ - diff --git a/sigc++/macros/signal.h.m4 b/sigc++/macros/signal.h.m4 deleted file mode 100644 index b9e2a2bb..00000000 --- a/sigc++/macros/signal.h.m4 +++ /dev/null @@ -1,1170 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -divert(-1) - -include(template.macros.m4) - -define([SIGNAL_EMIT_N],[dnl -/** Abstracts signal emission. - * This template implements the emit() function of signal$1. - * Template specializations are available to optimize signal - * emission when no accumulator is used, for example when the template - * argument @e T_accumulator is @p nil. - */ -template -struct signal_emit$1 -{ - typedef signal_emit$1 self_type; - typedef typename T_accumulator::result_type result_type; - typedef slot slot_type; - typedef internal::slot_iterator_buf slot_iterator_buf_type; - typedef internal::slot_reverse_iterator_buf slot_reverse_iterator_buf_type; - typedef signal_impl::const_iterator_type iterator_type; - -ifelse($1,0,,[dnl - /** Instantiates the class. - * The parameters are stored in member variables. operator()() passes - * the values on to some slot. - */ -])dnl - signal_emit$1(LOOP(type_trait_take_t _A_a%1, $1)) ifelse($1,0,,[ - : LOOP(_A_a%1_(_A_a%1), $1)]) {} - -ifelse($1,0,[dnl - /** Invokes a slot.],[ - /** Invokes a slot using the buffered parameter values.]) - * @param _A_slot Some slot to invoke. - * @return The slot's return value. - */ - T_return operator()(const slot_type& _A_slot) const - { return (reinterpret_cast(_A_slot.rep_->call_))(LIST(_A_slot.rep_, LOOP(_A_a%1_, $1))); } -dnl T_return operator()(const slot_type& _A_slot) const -dnl { return _A_slot(LOOP(_A_a%1_, $1)); } - - /** Executes a list of slots using an accumulator of type @e T_accumulator.dnl -ifelse($1,0,,[ - * The arguments are buffered in a temporary instance of signal_emit$1.]) -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the slots.]) - * @return The accumulated return values of the slot invocations as processed by the accumulator. - */ - static result_type emit(LIST(signal_impl* impl, LOOP(type_trait_take_t _A_a%1, $1))) - { - T_accumulator accumulator; - - if (!impl) - return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type()); - - signal_exec exec(impl); - temp_slot_list slots(impl->slots_); - - self_type self ifelse($1,0,,[(LOOP(_A_a%1, $1))]); - return accumulator(slot_iterator_buf_type(slots.begin(), &self), - slot_iterator_buf_type(slots.end(), &self)); - } - - /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.dnl -ifelse($1,0,,[ - * The arguments are buffered in a temporary instance of signal_emit$1.]) -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the slots.]) - * @return The accumulated return values of the slot invocations as processed by the accumulator. - */ - static result_type emit_reverse(LIST(signal_impl* impl, LOOP(type_trait_take_t _A_a%1, $1))) - { - T_accumulator accumulator; - - if (!impl) - return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type()); - - signal_exec exec(impl); - temp_slot_list slots(impl->slots_); - - self_type self ifelse($1,0,,[(LOOP(_A_a%1, $1))]); - return accumulator(slot_reverse_iterator_buf_type(slots.end(), &self), - slot_reverse_iterator_buf_type(slots.begin(), &self)); - } -dnl - FOR(1, $1,[ - type_trait_take_t _A_a%1_;]) -}; - -/** Abstracts signal emission. - * This template specialization implements an optimized emit() - * function for the case that no accumulator is used. - */ -template -struct signal_emit$1 -{ - typedef signal_emit$1 self_type; - typedef T_return result_type; - typedef slot slot_type; - typedef signal_impl::const_iterator_type iterator_type; - typedef typename slot_type::call_type call_type; - - /** Executes a list of slots using an accumulator of type @e T_accumulator.dnl -ifelse($1,0,,[ - * The arguments are passed directly on to the slots.]) - * The return value of the last slot invoked is returned. - * @param first An iterator pointing to the first slot in the list. - * @param last An iterator pointing to the last slot in the list.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the slots.]) - * @return The return value of the last slot invoked. - */ - static result_type emit(LIST(signal_impl* impl, LOOP(type_trait_take_t _A_a%1, $1))) - { - if (!impl || impl->slots_.empty()) - return T_return(); - - signal_exec exec(impl); - T_return r_ = T_return(); - - //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed. - //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249 - { - temp_slot_list slots(impl->slots_); - iterator_type it = slots.begin(); - for (; it != slots.end(); ++it) - if (!it->empty() && !it->blocked()) break; - - if (it == slots.end()) - return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows: - - r_ = (reinterpret_cast(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1))); - for (++it; it != slots.end(); ++it) - { - if (it->empty() || it->blocked()) - continue; - r_ = (reinterpret_cast(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1))); - } - } - - return r_; - } - - /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.dnl -ifelse($1,0,,[ - * The arguments are passed directly on to the slots.]) - * The return value of the last slot invoked is returned. - * @param first An iterator pointing to the first slot in the list. - * @param last An iterator pointing to the last slot in the list.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the slots.]) - * @return The return value of the last slot invoked. - */ - static result_type emit_reverse(LIST(signal_impl* impl, LOOP(type_trait_take_t _A_a%1, $1))) - { - if (!impl || impl->slots_.empty()) - return T_return(); - - signal_exec exec(impl); - T_return r_ = T_return(); - - //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed. - //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249 - { -#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR - typedef std::reverse_iterator reverse_iterator_type; -#else - typedef std::reverse_iterator reverse_iterator_type; -#endif - - temp_slot_list slots(impl->slots_); - reverse_iterator_type it(slots.end()); - for (; it != reverse_iterator_type(slots.begin()); ++it) - if (!it->empty() && !it->blocked()) break; - - if (it == reverse_iterator_type(slots.begin())) - return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows: - - r_ = (reinterpret_cast(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1))); - for (++it; it != reverse_iterator_type(slots.begin()); ++it) - { - if (it->empty() || it->blocked()) - continue; - r_ = (reinterpret_cast(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1))); - } - } - - return r_; - } -}; - -/** Abstracts signal emission. - * This template specialization implements an optimized emit() - * function for the case that no accumulator is used and the - * return type is @p void. - */ -template -struct signal_emit$1 -{ - typedef signal_emit$1 self_type; - typedef void result_type; - typedef slot slot_type; - typedef signal_impl::const_iterator_type iterator_type; - typedef ifelse($1,0,void (*call_type)(slot_rep*),typename slot_type::call_type call_type); - - /** Executes a list of slots using an accumulator of type @e T_accumulator.dnl -ifelse($1,0,,[ - * The arguments are passed directly on to the slots.]) - * @param first An iterator pointing to the first slot in the list. - * @param last An iterator pointing to the last slot in the list.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the slots.]) - */ - static result_type emit(LIST(signal_impl* impl, LOOP(type_trait_take_t _A_a%1, $1))) - { - if (!impl || impl->slots_.empty()) return; - signal_exec exec(impl); - temp_slot_list slots(impl->slots_); - - for (iterator_type it = slots.begin(); it != slots.end(); ++it) - { - if (it->empty() || it->blocked()) - continue; - (reinterpret_cast(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1))); - } - } - - /** Executes a list of slots using an accumulator of type @e T_accumulator in reverse order.dnl -ifelse($1,0,,[ - * The arguments are passed directly on to the slots.]) - * @param first An iterator pointing to the first slot in the list. - * @param last An iterator pointing to the last slot in the list.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the slots.]) - */ - static result_type emit_reverse(LIST(signal_impl* impl, LOOP(type_trait_take_t _A_a%1, $1))) - { - if (!impl || impl->slots_.empty()) return; - signal_exec exec(impl); - temp_slot_list slots(impl->slots_); - -#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR - typedef std::reverse_iterator reverse_iterator_type; -#else - typedef std::reverse_iterator reverse_iterator_type; -#endif - for (reverse_iterator_type it = reverse_iterator_type(slots.end()); it != reverse_iterator_type(slots.begin()); ++it) - { - if (it->empty() || it->blocked()) - continue; - (reinterpret_cast(it->rep_->call_))(LIST(it->rep_, LOOP(_A_a%1, $1))); - } - } -}; - -]) -define([SIGNAL_N],[dnl -/** Signal declaration. - * signal$1 can be used to connect() slots that are invoked - * during subsequent calls to emit(). Any functor or slot - * can be passed into connect(). It is converted into a slot - * implicitly. - * - * If you want to connect one signal to another, use make_slot() - * to retrieve a functor that emits the signal when invoked. - * - * Be careful if you directly pass one signal into the connect() - * method of another: a shallow copy of the signal is made and - * the signal's slots are not disconnected until both the signal - * and its clone are destroyed, which is probably not what you want! - * - * An STL-style list interface for the signal's list of slots - * can be retrieved with slots(). This interface supports - * iteration, insertion and removal of slots. - * - * The following template arguments are used: - * - @e T_return The desired return type for the emit() function (may be overridden by the accumulator).dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of emit().]) - * - @e T_accumulator The accumulator type used for emission. The default - * @p nil means that no accumulator should be used, for example if signal - * emission returns the return value of the last slot invoked. - * - * You should use the more convenient unnumbered sigc::signal template. - * - * @ingroup signal - */ -template -class signal$1 - : public signal_base -{ -public: - typedef internal::signal_emit$1 emitter_type; - typedef typename emitter_type::result_type result_type; - typedef slot slot_type; - typedef slot_list slot_list_type; - typedef typename slot_list_type::iterator iterator; - typedef typename slot_list_type::const_iterator const_iterator; - typedef typename slot_list_type::reverse_iterator reverse_iterator; - typedef typename slot_list_type::const_reverse_iterator const_reverse_iterator; - - /** Add a slot to the list of slots. - * Any functor or slot may be passed into connect(). - * It will be converted into a slot implicitly. - * The returned iterator may be stored for disconnection - * of the slot at some later point. It stays valid until - * the slot is removed from the list of slots. The iterator - * can also be implicitly converted into a sigc::connection object - * that may be used safely beyond the life time of the slot. - * - * std::function<> and C++11 lambda expressions are functors. - * These are examples of functors that can be connected to a signal. - * - * %std::bind() creates a functor, but this functor typically has an - * %operator()() which is a variadic template. - * Our functor_trait can't deduce the result type - * of such a functor. If you first assign the return value of %std::bind() - * to a std::function, you can connect the std::function to a signal. - * - * @param slot_ The slot to add to the list of slots. - * @return An iterator pointing to the new slot in the list. - */ - iterator connect(const slot_type& slot_) - { return iterator(signal_base::connect(static_cast(slot_))); } - - /** Add a slot to the list of slots. - * @see connect(const slot_type& slot_). - * - * @newin{2,8} - */ - iterator connect(slot_type&& slot_) - { return iterator(signal_base::connect(std::move(static_cast(slot_)))); } - - /** Triggers the emission of the signal. - * During signal emission all slots that have been connected - * to the signal are invoked unless they are manually set into - * a blocking state. The parameters are passed on to the slots. - * If @e T_accumulated is not @p nil, an accumulator of this type - * is used to process the return values of the slot invocations. - * Otherwise, the return value of the last slot invoked is returned.dnl -FOR(1, $1,[ - * @param _A_a%1 Argument to be passed on to the slots.]) - * @return The accumulated return values of the slot invocations. - */ - result_type emit(LOOP(type_trait_take_t _A_a%1, $1)) const - { return emitter_type::emit(LIST(impl_, LOOP(_A_a%1, $1))); } - - /** Triggers the emission of the signal in reverse order (see emit()). */ - result_type emit_reverse(LOOP(type_trait_take_t _A_a%1, $1)) const - { return emitter_type::emit_reverse(LIST(impl_, LOOP(_A_a%1, $1))); } - - /** Triggers the emission of the signal (see emit()). */ - result_type operator()(LOOP(type_trait_take_t _A_a%1, $1)) const - { return emit(LOOP(_A_a%1, $1)); } - - /** Creates a functor that calls emit() on this signal. - * @code - * sigc::mem_fun(mysignal, &sigc::signal$1::emit) - * @endcode - * yields the same result. - * @return A functor that calls emit() on this signal. - */ - bound_const_mem_functor$1, $1))> make_slot() const - { return bound_const_mem_functor$1, $1))>(this, &signal$1::emit); } - - /** Creates an STL-style interface for the signal's list of slots. - * This interface supports iteration, insertion and removal of slots. - * @return An STL-style interface for the signal's list of slots. - */ - slot_list_type slots() - { return slot_list_type(impl()); } - - /** Creates an STL-style interface for the signal's list of slots. - * This interface supports iteration, insertion and removal of slots. - * @return An STL-style interface for the signal's list of slots. - */ - const slot_list_type slots() const - { return slot_list_type(const_cast(this)->impl()); } - - signal$1() {} - - signal$1(const signal$1& src) - : signal_base(src) {} - - signal$1(signal$1&& src) - : signal_base(std::move(src)) {} - - signal$1& operator=(const signal$1& src) - { - signal_base::operator=(src); - return *this; - } - - signal$1& operator=(signal$1&& src) - { - signal_base::operator=(std::move(src)); - return *this; - } -}; - -]) -define([SIGNAL],[dnl -ifelse($1, $2,[dnl -/** Convenience wrapper for the numbered sigc::signal# templates. - * signal can be used to connect() slots that are invoked - * during subsequent calls to emit(). Any functor or slot - * can be passed into connect(). It is converted into a slot - * implicitly. - * - * If you want to connect one signal to another, use make_slot() - * to retrieve a functor that emits the signal when invoked. - * - * Be careful if you directly pass one signal into the connect() - * method of another: a shallow copy of the signal is made and - * the signal's slots are not disconnected until both the signal - * and its clone are destroyed, which is probably not what you want! - * - * An STL-style list interface for the signal's list of slots - * can be retrieved with slots(). This interface supports - * iteration, insertion and removal of slots. - * - * The template arguments determine the function signature of - * the emit() function: - * - @e T_return The desired return type of the emit() function.dnl -FOR(1,$1,[ - * - @e T_arg%1 Argument type used in the definition of emit(). The default @p nil means no argument.]) - * - * To specify an accumulator type the nested class signal::accumulated can be used. - * - * @par Example: - * @code - * void foo(int) {} - * sigc::signal sig; - * sig.connect(sigc::ptr_fun(&foo)); - * sig.emit(19); - * @endcode - * - * @ingroup signal - */ -template ],[dnl - -/** Convenience wrapper for the numbered sigc::signal$1 template. - * See the base class for useful methods. - * This is the template specialization of the unnumbered sigc::signal - * template for $1 argument(s). -ifelse($1, $2,[dnl - * - * @ingroup signal -])dnl - */ -template ]) -class signal ifelse($1, $2,,[]) - : public signal$1 -{ -public: -ifelse($1, $2,[dnl - /** Convenience wrapper for the numbered sigc::signal# templates. - * Like sigc::signal but the additional template parameter @e T_accumulator - * defines the accumulator type that should be used. - * - * An accumulator is a functor that uses a pair of special iterators - * to step through a list of slots and calculate a return value - * from the results of the slot invokations. The iterators' operator*() - * executes the slot. The return value is buffered, so that in an expression - * like @code a = (*i) * (*i); @endcode the slot is executed only once. - * The accumulator must define its return value as @p result_type. - * - * @par Example 1: - * This accumulator calculates the arithmetic mean value: - * @code - * struct arithmetic_mean_accumulator - * { - * typedef double result_type; - * template - * result_type operator()(T_iterator first, T_iterator last) const - * { - * result_type value_ = 0; - * int n_ = 0; - * for (; first != last; ++first, ++n_) - * value_ += *first; - * return value_ / n_; - * } - * }; - * @endcode - * - * @par Example 2: - * This accumulator stops signal emission when a slot returns zero: - * @code - * struct interruptable_accumulator - * { - * typedef bool result_type; - * template - * result_type operator()(T_iterator first, T_iterator last) const - * { - * for (; first != last; ++first, ++n_) - * if (!*first) return false; - * return true; - * } - * }; - * @endcode - * - * @ingroup signal -],[ - /** Convenience wrapper for the numbered sigc::signal$1 template. - * Like sigc::signal but the additional template parameter @e T_accumulator - * defines the accumulator type that should be used. -])dnl - */ - template - class accumulated - : public signal$1 - { - public: - accumulated() {} - accumulated(const accumulated& src) - : signal$1(src) {} - }; - - signal() {} - - signal(const signal& src) - : signal$1(src) {} - - signal(signal&& src) - : signal$1(std::move(src)) {} - - signal& operator=(const signal& src) - { - signal$1::operator=(src); - return *this; - } - - signal& operator=(signal&& src) - { - signal$1::operator=(std::move(src)); - return *this; - } -}; - -]) - -divert(0) -#ifndef _SIGC_SIGNAL_H_ -#define _SIGC_SIGNAL_H_ - -#include -#include -#include -#include -#include -#include - -//TODO: See comment in functor_trait.h. -#if defined(nil) && defined(SIGC_PRAGMA_PUSH_POP_MACRO) - #define SIGC_NIL_HAS_BEEN_PUSHED 1 - #pragma push_macro("nil") - #undef nil -#endif - -//SIGC_TYPEDEF_REDEFINE_ALLOWED: -// TODO: This should have its own test, but I can not create one that gives the error instead of just a warning. murrayc. -// I have just used this because there is a correlation between these two problems. -#ifdef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - //Compilers, such as older versions of SUN Forte C++, that do not allow this also often - //do not allow a typedef to have the same name as a class in the typedef's definition. - //For Sun Forte CC 5.7 (SUN Workshop 10), comment this out to fix the build. - #define SIGC_TYPEDEF_REDEFINE_ALLOWED 1 -#endif - -namespace sigc { - -/** STL-style iterator for slot_list. - * - * @ingroup signal - */ -template -struct slot_iterator -{ - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - - typedef T_slot slot_type; - - typedef T_slot value_type; - typedef T_slot* pointer; - typedef T_slot& reference; - - typedef typename internal::signal_impl::iterator_type iterator_type; - - slot_iterator() - {} - - explicit slot_iterator(const iterator_type& i) - : i_(i) {} - - reference operator*() const - { return static_cast(*i_); } - - pointer operator->() const - { return &(operator*()); } - - slot_iterator& operator++() - { - ++i_; - return *this; - } - - slot_iterator operator++(int) - { - slot_iterator __tmp(*this); - ++i_; - return __tmp; - } - - slot_iterator& operator--() - { - --i_; - return *this; - } - - slot_iterator operator--(int) - { - slot_iterator __tmp(*this); - --i_; - return __tmp; - } - - bool operator == (const slot_iterator& other) const - { return i_ == other.i_; } - - bool operator != (const slot_iterator& other) const - { return i_ != other.i_; } - - iterator_type i_; -}; - -/** STL-style const iterator for slot_list. - * - * @ingroup signal - */ -template -struct slot_const_iterator -{ - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - - typedef T_slot slot_type; - - typedef T_slot value_type; - typedef const T_slot* pointer; - typedef const T_slot& reference; - - typedef typename internal::signal_impl::const_iterator_type iterator_type; - - slot_const_iterator() - {} - - explicit slot_const_iterator(const iterator_type& i) - : i_(i) {} - - reference operator*() const - { return static_cast(*i_); } - - pointer operator->() const - { return &(operator*()); } - - slot_const_iterator& operator++() - { - ++i_; - return *this; - } - - slot_const_iterator operator++(int) - { - slot_const_iterator __tmp(*this); - ++i_; - return __tmp; - } - - slot_const_iterator& operator--() - { - --i_; - return *this; - } - - slot_const_iterator operator--(int) - { - slot_const_iterator __tmp(*this); - --i_; - return __tmp; - } - - bool operator == (const slot_const_iterator& other) const - { return i_ == other.i_; } - - bool operator != (const slot_const_iterator& other) const - { return i_ != other.i_; } - - iterator_type i_; -}; - -/** STL-style list interface for sigc::signal#. - * slot_list can be used to iterate over the list of slots that - * is managed by a signal. Slots can be added or removed from - * the list while existing iterators stay valid. A slot_list - * object can be retrieved from the signal's slots() function. - * - * @ingroup signal - */ -template -struct slot_list -{ - typedef T_slot slot_type; - - typedef slot_type& reference; - typedef const slot_type& const_reference; - - typedef slot_iterator iterator; - typedef slot_const_iterator const_iterator; - - #ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; - #else - typedef std::reverse_iterator reverse_iterator; - - typedef std::reverse_iterator const_reverse_iterator; - #endif /* SIGC_HAVE_SUN_REVERSE_ITERATOR */ - - - slot_list() - : list_(nullptr) {} - - explicit slot_list(internal::signal_impl* __list) - : list_(__list) {} - - iterator begin() - { return iterator(list_->slots_.begin()); } - - const_iterator begin() const - { return const_iterator(list_->slots_.begin()); } - - iterator end() - { return iterator(list_->slots_.end()); } - - const_iterator end() const - { return const_iterator(list_->slots_.end()); } - - reverse_iterator rbegin() - { return reverse_iterator(end()); } - - const_reverse_iterator rbegin() const - { return const_reverse_iterator(end()); } - - reverse_iterator rend() - { return reverse_iterator(begin()); } - - const_reverse_iterator rend() const - { return const_reverse_iterator(begin()); } - - reference front() - { return *begin(); } - - const_reference front() const - { return *begin(); } - - reference back() - { return *(--end()); } - - const_reference back() const - { return *(--end()); } - - iterator insert(iterator i, const slot_type& slot_) - { return iterator(list_->insert(i.i_, static_cast(slot_))); } - - iterator insert(iterator i, slot_type&& slot_) - { return iterator(list_->insert(i.i_, std::move(static_cast(slot_)))); } - - void push_front(const slot_type& c) - { insert(begin(), c); } - - void push_front(slot_type&& c) - { insert(begin(), std::move(c)); } - - void push_back(const slot_type& c) - { insert(end(), c); } - - void push_back(slot_type&& c) - { insert(end(), std::move(c)); } - - iterator erase(iterator i) - { return iterator(list_->erase(i.i_)); } - - iterator erase(iterator first_, iterator last_) - { - while (first_ != last_) - first_ = erase(first_); - return last_; - } - - void pop_front() - { erase(begin()); } - - void pop_back() - { - auto tmp_ = end(); - erase(--tmp_); - } - -protected: - internal::signal_impl* list_; -}; - - -namespace internal { - -/** Special iterator over sigc::internal::signal_impl's slot list that holds extra data. - * This iterators is for use in accumulators. operator*() executes - * the slot. The return value is buffered, so that in an expression - * like @code a = (*i) * (*i); @endcode the slot is executed only once. - */ -template -struct slot_iterator_buf -{ - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - - //These are needed just to make this a proper C++ iterator, - //that can be used with standard C++ algorithms. - typedef T_result value_type; - typedef T_result& reference; - typedef T_result* pointer; - - typedef T_emitter emitter_type; - typedef T_result result_type; - typedef typename T_emitter::slot_type slot_type; - - typedef signal_impl::const_iterator_type iterator_type; - - slot_iterator_buf() - : c_(nullptr), invoked_(false) {} - - slot_iterator_buf(const iterator_type& i, const emitter_type* c) - : i_(i), c_(c), invoked_(false) {} - - result_type operator*() const - { - if (!i_->empty() && !i_->blocked() && !invoked_) - { - r_ = (*c_)(static_cast(*i_)); - invoked_ = true; - } - return r_; - } - - slot_iterator_buf& operator++() - { - ++i_; - invoked_ = false; - return *this; - } - - slot_iterator_buf operator++(int) - { - slot_iterator_buf __tmp(*this); - ++i_; - invoked_ = false; - return __tmp; - } - - slot_iterator_buf& operator--() - { - --i_; - invoked_ = false; - return *this; - } - - slot_iterator_buf operator--(int) - { - slot_iterator_buf __tmp(*this); - --i_; - invoked_ = false; - return __tmp; - } - - bool operator == (const slot_iterator_buf& other) const - { return (!c_ || (i_ == other.i_)); } /* If '!c_' the iterators are empty. - * Unfortunately, empty stl iterators are not equal. - * We are forcing equality so that 'first==last' - * in the accumulator's emit function yields true. */ - - bool operator != (const slot_iterator_buf& other) const - { return (c_ && (i_ != other.i_)); } - -private: - iterator_type i_; - const emitter_type* c_; - mutable result_type r_; - mutable bool invoked_; -}; - -/** Template specialization of slot_iterator_buf for void return signals. - */ -template -struct slot_iterator_buf -{ - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - - typedef T_emitter emitter_type; - typedef void result_type; - typedef typename T_emitter::slot_type slot_type; - - typedef signal_impl::const_iterator_type iterator_type; - - slot_iterator_buf() - : c_(nullptr), invoked_(false) {} - - slot_iterator_buf(const iterator_type& i, const emitter_type* c) - : i_(i), c_(c), invoked_(false) {} - - void operator*() const - { - if (!i_->empty() && !i_->blocked() && !invoked_) - { - (*c_)(static_cast(*i_)); - invoked_ = true; - } - } - - slot_iterator_buf& operator++() - { - ++i_; - invoked_ = false; - return *this; - } - - slot_iterator_buf operator++(int) - { - slot_iterator_buf __tmp(*this); - ++i_; - invoked_ = false; - return __tmp; - } - - slot_iterator_buf& operator--() - { - --i_; - invoked_ = false; - return *this; - } - - slot_iterator_buf operator--(int) - { - slot_iterator_buf __tmp(*this); - --i_; - invoked_ = false; - return __tmp; - } - - bool operator == (const slot_iterator_buf& other) const - { return i_ == other.i_; } - - bool operator != (const slot_iterator_buf& other) const - { return i_ != other.i_; } - -private: - iterator_type i_; - const emitter_type* c_; - mutable bool invoked_; -}; - -/** Reverse version of sigc::internal::slot_iterator_buf. */ -template -struct slot_reverse_iterator_buf -{ - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - - //These are needed just to make this a proper C++ iterator, - //that can be used with standard C++ algorithms. - typedef T_result value_type; - typedef T_result& reference; - typedef T_result* pointer; - - typedef T_emitter emitter_type; - typedef T_result result_type; - typedef typename T_emitter::slot_type slot_type; - - typedef signal_impl::const_iterator_type iterator_type; - - slot_reverse_iterator_buf() - : c_(nullptr), invoked_(false) {} - - slot_reverse_iterator_buf(const iterator_type& i, const emitter_type* c) - : i_(i), c_(c), invoked_(false) {} - - result_type operator*() const - { - iterator_type __tmp(i_); - --__tmp; - if (!__tmp->empty() && !__tmp->blocked() && !invoked_) - { - r_ = (*c_)(static_cast(*__tmp)); - invoked_ = true; - } - return r_; - } - - slot_reverse_iterator_buf& operator++() - { - --i_; - invoked_ = false; - return *this; - } - - slot_reverse_iterator_buf operator++(int) - { - slot_reverse_iterator_buf __tmp(*this); - --i_; - invoked_ = false; - return __tmp; - } - - slot_reverse_iterator_buf& operator--() - { - ++i_; - invoked_ = false; - return *this; - } - - slot_reverse_iterator_buf operator--(int) - { - slot_reverse_iterator_buf __tmp(*this); - ++i_; - invoked_ = false; - return __tmp; - } - - bool operator == (const slot_reverse_iterator_buf& other) const - { return (!c_ || (i_ == other.i_)); } /* If '!c_' the iterators are empty. - * Unfortunately, empty stl iterators are not equal. - * We are forcing equality so that 'first==last' - * in the accumulator's emit function yields true. */ - - bool operator != (const slot_reverse_iterator_buf& other) const - { return (c_ && (i_ != other.i_)); } - -private: - iterator_type i_; - const emitter_type* c_; - mutable result_type r_; - mutable bool invoked_; -}; - -/** Template specialization of slot_reverse_iterator_buf for void return signals. - */ -template -struct slot_reverse_iterator_buf -{ - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - - typedef T_emitter emitter_type; - typedef void result_type; - typedef typename T_emitter::slot_type slot_type; - - typedef signal_impl::const_iterator_type iterator_type; - - slot_reverse_iterator_buf() - : c_(nullptr), invoked_(false) {} - - slot_reverse_iterator_buf(const iterator_type& i, const emitter_type* c) - : i_(i), c_(c), invoked_(false) {} - - void operator*() const - { - iterator_type __tmp(i_); - --__tmp; - if (!__tmp->empty() && !__tmp->blocked() && !invoked_) - { - (*c_)(static_cast(*__tmp)); - invoked_ = true; - } - } - - slot_reverse_iterator_buf& operator++() - { - --i_; - invoked_ = false; - return *this; - } - - slot_reverse_iterator_buf operator++(int) - { - slot_reverse_iterator_buf __tmp(*this); - --i_; - invoked_ = false; - return __tmp; - } - - slot_reverse_iterator_buf& operator--() - { - ++i_; - invoked_ = false; - return *this; - } - - slot_reverse_iterator_buf operator--(int) - { - slot_reverse_iterator_buf __tmp(*this); - ++i_; - invoked_ = false; - return __tmp; - } - - bool operator == (const slot_reverse_iterator_buf& other) const - { return i_ == other.i_; } - - bool operator != (const slot_reverse_iterator_buf& other) const - { return i_ != other.i_; } - -private: - iterator_type i_; - const emitter_type* c_; - mutable bool invoked_; -}; - -FOR(0,CALL_SIZE,[[SIGNAL_EMIT_N(%1)]]) -} /* namespace internal */ - -FOR(0,CALL_SIZE,[[SIGNAL_N(%1)]]) - -SIGNAL(CALL_SIZE,CALL_SIZE) -FOR(0,eval(CALL_SIZE-1),[[SIGNAL(%1)]]) - -} /* namespace sigc */ - -#ifdef SIGC_NIL_HAS_BEEN_PUSHED - #undef SIGC_NIL_HAS_BEEN_PUSHED - #pragma pop_macro("nil") -#endif - -#endif /* _SIGC_SIGNAL_H_ */ diff --git a/sigc++/macros/template.macros.m4 b/sigc++/macros/template.macros.m4 deleted file mode 100644 index 8a41bcc5..00000000 --- a/sigc++/macros/template.macros.m4 +++ /dev/null @@ -1,86 +0,0 @@ -dnl Copyright 2002, The libsigc++ Development Team -dnl -dnl This library is free software; you can redistribute it and/or -dnl modify it under the terms of the GNU Lesser General Public -dnl License as published by the Free Software Foundation; either -dnl version 2.1 of the License, or (at your option) any later version. -dnl -dnl This library is distributed in the hope that it will be useful, -dnl but WITHOUT ANY WARRANTY; without even the implied warranty of -dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -dnl Lesser General Public License for more details. -dnl -dnl You should have received a copy of the GNU Lesser General Public -dnl License along with this library; if not, write to the Free Software -dnl Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -dnl -define(__t_div__,divnum)divert(-1) -dnl -dnl M4 macros for building large files quickly -dnl -divert(0)// -*- c++ -*- -/* Do not edit! -- generated file */ -divert(-1) -changequote([, ]) -changecom() - -dnl -dnl Macros for sigc specifically. -dnl - -define([CALL_SIZE],7) - -#Generate header guards: -define([_FIREWALL],[dnl -#ifndef _SIGC_$1_H_ -#define _SIGC_$1_H_[]dnl -divert(1)dnl -#endif /* _SIGC_$1_H_ */ -divert(0)dnl -]) - -define([_R_],[type_trait_take_t<$1>]) -define([_P_],[type_trait_pass_t<$1>]) - -define([__DEPRECATION_GUARD__],[SIGCXX_DISABLE_DEPRECATED])dnl -dnl Start deprecation -define([_DEPRECATE_IFDEF_START],[dnl -#ifndef __DEPRECATION_GUARD__])dnl -dnl End deprecation -define([_DEPRECATE_IFDEF_END],[dnl -#endif // __DEPRECATION_GUARD__])dnl - -dnl -dnl General macros -dnl - -define([PROT],[[$*]]) - -define([_LOOP], -[ifelse(eval($1<$2),0, -[indir([_LOOP_FORMAT], $1)], -[indir([_LOOP_FORMAT], $1)[]_LOOP_SEP[]_LOOP(eval($1+1), $2)])]) - -define([LOOP], -[pushdef([_LOOP_FORMAT], translit([$1],%, $))dnl -pushdef([_LOOP_SEP],ifelse([$3],[],[[[, ]]],[$3]))dnl -ifelse(eval($2>0),1,[PROT(_LOOP(1, $2))],[PROT()])dnl -popdef([_LOOP_SEP])dnl -popdef([_LOOP_FORMAT])dnl -]) - -define([NUM],[eval(ifelse([$1],,0,1)ifelse($#,0,0, $#,1,,[+NUM(shift($@))]))]) -define([LIST],[ifelse($#,0,, $#,1,[$1],[$1],,[LIST(shift($@))],[__LIST($@)])]) -define([__LIST],[ifelse($#,0,, $#,1,[$1],[$1[]ifelse([$2],,,[[, ]])__LIST(shift($@))])]) -dnl -define([_NL_],[ -]) - -define([FOR], -[pushdef([_FOR_FUNC],PROT(translit([$3],%, $)))dnl -_FOR($1, $2)[]dnl -popdef([_FOR_FUNC])dnl -]) -define([_FOR],[ifelse(eval($1>$2),1,[],[_FOR_FUNC($1)[]_FOR(eval($1+1), $2)])]) - -divert(__t_div__)dnl diff --git a/sigc++/member_method_trait.h b/sigc++/member_method_trait.h new file mode 100644 index 00000000..9d9b2a07 --- /dev/null +++ b/sigc++/member_method_trait.h @@ -0,0 +1,147 @@ +/* Copyright 2002 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ +#ifndef SIGC_MEMBER_METHOD_TRAITS_H +#define SIGC_MEMBER_METHOD_TRAITS_H + +#include + +namespace sigc +{ + +namespace internal +{ + +template +struct member_method_is_const; + +template +struct member_method_is_const +{ + constexpr static bool value = false; +}; + +template +struct member_method_is_const +{ + constexpr static bool value = false; +}; + +template +struct member_method_is_const +{ + constexpr static bool value = true; +}; + +template +struct member_method_is_const +{ + constexpr static bool value = true; +}; + +template +struct member_method_is_volatile; + +template +struct member_method_is_volatile +{ + constexpr static bool value = false; +}; + +template +struct member_method_is_volatile +{ + constexpr static bool value = false; +}; + +template +struct member_method_is_volatile +{ + constexpr static bool value = true; +}; + +template +struct member_method_is_volatile +{ + constexpr static bool value = true; +}; + +// member method class: + +template +struct member_method_class +{ +}; + +template +struct member_method_class +{ + using type = T_obj; +}; + +template +struct member_method_class +{ + using type = T_obj; +}; + +template +struct member_method_class +{ + using type = T_obj; +}; + +template +struct member_method_class +{ + using type = T_obj; +}; + +// member method result: + +template +struct member_method_result +{ +}; + +template +struct member_method_result +{ + using type = T_result; +}; + +template +struct member_method_result +{ + using type = T_result; +}; + +template +struct member_method_result +{ + using type = T_result; +}; + +template +struct member_method_result +{ + using type = T_result; +}; + +} // namespace internal + +} // namespace sigc + +#endif /* SIGC_MEMBER_METHOD_TRAITS_H */ diff --git a/sigc++/meson.build b/sigc++/meson.build new file mode 100644 index 00000000..4f62bad0 --- /dev/null +++ b/sigc++/meson.build @@ -0,0 +1,142 @@ +# sigc++ + +# Input: sigcxx_build_dep, sigcxx_pcname, sigcxx_libversion, sigcxx_api_version, +# darwin_versions, install_includedir, sig_rc, msvc_static_cxxflag, +# is_msvc_style +# Output: source_h_files, sigcxx_own_dep + +# There are no built source files in libsigc++-3.0. + +source_cc_files = [ + 'connection.cc', + 'scoped_connection.cc', + 'signal_base.cc', + 'trackable.cc', + 'functors' / 'slot_base.cc', +] + +sigc_h_files = [ + 'bind.h', + 'bind_return.h', + 'connection.h', + 'limit_reference.h', + 'member_method_trait.h', + 'reference_wrapper.h', + 'retype_return.h', + 'scoped_connection.h', + 'signal.h', + 'signal_base.h', + 'signal_connect.h', + 'slot.h', + 'trackable.h', + 'type_traits.h', + 'visit_each.h', + 'weak_raw_ptr.h', +] +adaptors_h_files = [ + 'adaptors' / 'adaptor_base.h', + 'adaptors' / 'adaptors.h', + 'adaptors' / 'adaptor_trait.h', + 'adaptors' / 'adapts.h', + 'adaptors' / 'bind.h', + 'adaptors' / 'bind_return.h', + 'adaptors' / 'bound_argument.h', + 'adaptors' / 'compose.h', + 'adaptors' / 'exception_catch.h', + 'adaptors' / 'hide.h', + 'adaptors' / 'retype.h', + 'adaptors' / 'retype_return.h', + 'adaptors' / 'track_obj.h', + 'adaptors' / 'tuple_visitor_visit_each.h', +] +functors_h_files = [ + 'functors' / 'functor_trait.h', + 'functors' / 'functors.h', + 'functors' / 'mem_fun.h', + 'functors' / 'ptr_fun.h', + 'functors' / 'slot.h', + 'functors' / 'slot_base.h', +] +tuple_utils_h_files = [ + 'tuple-utils' / 'tuple_cdr.h', + 'tuple-utils' / 'tuple_end.h', + 'tuple-utils' / 'tuple_for_each.h', + 'tuple-utils' / 'tuple_start.h', + 'tuple-utils' / 'tuple_transform_each.h', +] + +source_h_files = sigc_h_files + adaptors_h_files + functors_h_files + tuple_utils_h_files + +install_headers('sigc++.h', subdir: sigcxx_pcname / 'sigc++') +install_headers(sigc_h_files, subdir: sigcxx_pcname / 'sigc++') +install_headers(adaptors_h_files, subdir: sigcxx_pcname / 'sigc++' / 'adaptors') +install_headers(functors_h_files, subdir: sigcxx_pcname / 'sigc++' / 'functors') +install_headers(tuple_utils_h_files, subdir: sigcxx_pcname / 'sigc++' / 'tuple-utils') + +extra_sigc_cppflags = [] +extra_sigc_objects = [] + +# Make sure we are exporting the symbols from the DLL +if is_msvc_style + extra_sigc_cppflags += ['-DSIGC_BUILD'] +endif + +# Build the .rc file for Windows builds and link to it +if host_machine.system() == 'windows' + windows = import('windows') + if get_option('default_library') == 'shared' + sigc_res = windows.compile_resources(sigc_rc) + extra_sigc_objects += sigc_res + endif +endif + +extra_include_dirs = ['..'] +sigcxx_library = library('sigc-' + sigcxx_api_version, + source_cc_files, + extra_sigc_objects, + version: sigcxx_libversion, + darwin_versions: darwin_versions, + implicit_include_directories: false, + include_directories: extra_include_dirs, + cpp_args: extra_sigc_cppflags, + dependencies: sigcxx_build_dep, + install: true, +) + +# Generate .pc files, used by pkg-config. +pkg_config = import('pkgconfig') +pc_common_variables = [ + 'doxytagfile=${docdir}/reference/lib' + sigcxx_pcname + '.tag', + 'htmlrefdir=${docdir}/reference/html', + 'htmlrefpub=https://libsigcplusplus.github.io/libsigcplusplus/reference/html', +] +pc_variables = [ + 'exec_prefix=${prefix}', + 'datarootdir=${datadir}', + 'docdir=${datadir}/doc/lib' + sigcxx_pcname, +] + pc_common_variables +pc_uninstalled_variables = [ + 'docdir=${prefix}/docs/docs', +] + pc_common_variables + +pkg_config.generate(sigcxx_library, + filebase: sigcxx_pcname, + variables: pc_variables, + uninstalled_variables: pc_uninstalled_variables, + name: meson.project_name(), + description: 'Typesafe signal and callback system for C++', + url: 'https://libsigcplusplus.github.io/libsigcplusplus/', + subdirs: [sigcxx_pcname], + extra_cflags: [ + '-I${libdir}/' + sigcxx_pcname + '/include', + msvc_static_cxxflag, + ], +) + +# This is used when building example programs and test programs. +# It's also a part of sigcxx_dep, when libsigc++ is a subproject. +sigcxx_own_dep = declare_dependency( + link_with: sigcxx_library, + include_directories: extra_include_dirs, + dependencies: sigcxx_build_dep +) diff --git a/sigc++/reference_wrapper.h b/sigc++/reference_wrapper.h index 5a57e916..df256a6f 100644 --- a/sigc++/reference_wrapper.h +++ b/sigc++/reference_wrapper.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,99 +11,48 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_REFERENCE_WRAPPER_H_ -#define _SIGC_REFERENCE_WRAPPER_H_ - -namespace sigc { - -/** Reference wrapper. - * Use sigc::ref() to create a reference wrapper. - */ -template -struct reference_wrapper -{ - explicit reference_wrapper(T_type& v) - : value_(v) {} +#ifndef SIGC_REFERENCE_WRAPPER_H +#define SIGC_REFERENCE_WRAPPER_H - operator T_type& () const - { return value_; } +#include - T_type& value_; -}; - -/** Const reference wrapper. - * Use sigc::ref() to create a const reference wrapper. - */ -template -struct const_reference_wrapper +namespace sigc { - explicit const_reference_wrapper(const T_type& v) - : value_(v) {} - operator const T_type& () const - { return value_; } - - const T_type& value_; -}; - -/** Creates a reference wrapper. - * Passing an object throught sigc::ref() makes libsigc++ adaptors - * like, e.g., sigc::bind store references to the object instead of copies. - * If the object type inherits from sigc::trackable this will ensure - * automatic invalidation of the adaptors when the object is deleted - * or overwritten. - * - * @param v Reference to store. - * @return A reference wrapper. - */ -template -reference_wrapper ref(T_type& v) -{ return reference_wrapper(v); } - -/** Creates a const reference wrapper. - * Passing an object throught sigc::ref() makes libsigc++ adaptors - * like, e.g., sigc::bind store references to the object instead of copies. - * If the object type inherits from sigc::trackable this will ensure - * automatic invalidation of the adaptors when the object is deleted - * or overwritten. - * - * @param v Reference to store. - * @return A reference wrapper. - */ -template -const_reference_wrapper ref(const T_type& v) -{ return const_reference_wrapper(v); } - -template +template struct unwrap_reference { - typedef T_type type; + using type = T_type; }; -template -struct unwrap_reference > +template +struct unwrap_reference> { - typedef T_type& type; + using type = T_type&; }; -template -struct unwrap_reference > +template +struct unwrap_reference> { - typedef const T_type& type; + using type = const T_type&; }; -template -T_type& unwrap(const reference_wrapper& v) -{ return v; } +template +T_type& +unwrap(const std::reference_wrapper& v) +{ + return v; +} -template -const T_type& unwrap(const const_reference_wrapper& v) -{ return v; } +template +const T_type& +unwrap(const std::reference_wrapper& v) +{ + return v; +} } /* namespace sigc */ -#endif /* _SIGC_REFERENCE_WRAPPER_H_ */ +#endif /* SIGC_REFERENCE_WRAPPER_H */ diff --git a/sigc++/retype_return.h b/sigc++/retype_return.h index c1d08d7e..8264c713 100644 --- a/sigc++/retype_return.h +++ b/sigc++/retype_return.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,14 +11,11 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_RETYPE_RETURN_HPP_ -#define _SIGC_RETYPE_RETURN_HPP_ +#ifndef SIGC_RETYPE_RETURN_HPP +#define SIGC_RETYPE_RETURN_HPP #include - -#endif /* _SIGC_RETYPE_RETURN_HPP_ */ +#endif /* SIGC_RETYPE_RETURN_HPP */ diff --git a/sigc++/scoped_connection.cc b/sigc++/scoped_connection.cc new file mode 100644 index 00000000..1eae69f0 --- /dev/null +++ b/sigc++/scoped_connection.cc @@ -0,0 +1,114 @@ +/* Copyright 2023, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#include +#include + +namespace sigc +{ + +// All we are doing is assigning weak_raw_ptr, which is noexcept, so declare it. +// connectionʼs copy operators can be noexcept for that reason, if breaking ABI. +scoped_connection::scoped_connection(connection c) noexcept +: conn_(std::move(c)) +{ +} + +scoped_connection& +scoped_connection::operator=(connection c) +{ + conn_.disconnect(); + conn_ = std::move(c); + return *this; +} + +// We do not implement move-ctor in terms of move-assign, so we can be noexcept, +// as we do not need to call the maybe-throwing disconnect() for obvious reason. +scoped_connection::scoped_connection(scoped_connection&& sc) noexcept +: conn_(std::exchange(sc.conn_, connection())) +{ +} + +scoped_connection& +scoped_connection::operator=(scoped_connection&& sc) +{ + conn_.disconnect(); + conn_ = std::exchange(sc.conn_, connection()); + return *this; +} + +scoped_connection::~scoped_connection() +{ + conn_.disconnect(); +} + +bool +scoped_connection::empty() const noexcept +{ + return conn_.empty(); +} + +bool +scoped_connection::connected() const noexcept +{ + return conn_.connected(); +} + +bool +scoped_connection::blocked() const noexcept +{ + return conn_.blocked(); +} + +bool +scoped_connection::block(bool should_block) noexcept +{ + return conn_.block(should_block); +} + +bool +scoped_connection::unblock() noexcept +{ + return conn_.unblock(); +} + +void +scoped_connection::disconnect() +{ + conn_.disconnect(); +} + +scoped_connection::operator bool() const noexcept +{ + return conn_.operator bool(); +} + +// Swapping can be noexcept, as it does not need to disconnect either connection +// because they will still stay alive, just in opposite instances post-swapping. +void +swap(scoped_connection& sca, scoped_connection& scb) noexcept +{ + using std::swap; + swap(sca.conn_, scb.conn_); +} + +connection +scoped_connection::release() noexcept +{ + return std::exchange(conn_, connection()); +} + +} /* namespace sigc */ diff --git a/sigc++/scoped_connection.h b/sigc++/scoped_connection.h new file mode 100644 index 00000000..3b297f91 --- /dev/null +++ b/sigc++/scoped_connection.h @@ -0,0 +1,175 @@ +/* Copyright 2023, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_SCOPED_CONNECTION_HPP +#define SIGC_SCOPED_CONNECTION_HPP + +#include + +namespace sigc +{ + +/** Convenience class for safe disconnection, including automatic disconnection + * upon destruction. + * + * This is a variant of @ref sigc::connection which also disconnect()s the slot + * automatically when the scoped_connection is destructed or re-assigned. Refer + * to @ref sigc::connection for full information about the common functionality. + * + * You will use sigc::scoped_connection by constructing it from a ‘normal’, + * unscoped @ref sigc::connection, such as those returned by + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" and + * @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()", + * thus ‘wrapping’ the connection in a scoped_connection, adding auto-disconnection. + * It can also be assigned from an unscoped connection, in which case, if there + * was a previous slot referred to by the scoped connection, it is disconnected. + * + * Once a connection is scoped, it canʼt be copied as that would make it unclear + * which of the copies would hold responsibility to auto-disconnect the slot. It + * can, however, be moved, so itʼs usable in containers or so ‘ownership’ of the + * connection/auto-disconnect can be moved to another instance. Moving from the + * scoped_connection clears its reference to the slot so it wonʼt disconnect it. + * + * If you want a reference-counted scoped_connection, wrap in a std::shared_ptr. + * + * @code + * // Automatic disconnection: + * { + * sigc::scoped_connection sconn = sig.connect(&some_function); + * // Do stuff that requires the slot to be connected & called. + * } + * // The scoped_connection was destroyed, so the slot is no longer connected. + * + * // *** + * + * // Moving ownership: + * { + * sigc::scoped_connection sconn = sig.connect(&some_function); + * // Do stuff that requires the slot to be connected & called. + * take_ownership(std::move(sconn)); // Pass by rvalue. + * } + * // Now our `sconn` no longer referred to slot, so it did NOT auto-disconnect. + * + * // *** + * + * // Shared ownership: + * { + * auto shconn = std::make_shared(sig.connect(&some_function)); + * take_copy(shconn); // Pass by copy/value + * // Now we AND take_copy() must destroy our shared_ptr to auto-disconnect(). + * } + * // take_copy() may still hold a shared_ptr reference, keeping the slot alive. + * @endcode + * + * @ingroup signal + * @newin{3,6} + */ +struct SIGC_API scoped_connection final +{ + /** Constructs an empty scoped connection object. */ + scoped_connection() noexcept = default; + + /** Constructs a scoped connection object from an unscoped connection object. + * The source connection still refers to the slot and can manually disconnect. + * @param c The connection object to make a copy from, whose slot weʼll + * automatically disconnect when the scoped_connection object is destroyed. + */ + scoped_connection(connection c) noexcept; + + /** Overrides this scoped connection object copying an unscoped connection. + * The current slot, if any, will be disconnect()ed before being replaced. + * The source connection still refers to the slot and can manually disconnect. + * @param c The connection object to make a copy from, whose slot weʼll + * automatically disconnect when the scoped_connection object is destroyed. + */ + scoped_connection& operator=(connection c); + + /// scoped_connection canʼt be copied as it would confuse ownership—see intro. + scoped_connection& operator=(const scoped_connection&) = delete; + /// scoped_connection canʼt be copied as it would confuse ownership—see intro. + scoped_connection(const scoped_connection&) = delete; + + /** Constructs a scoped connection object moving an existing one. + * The source scoped connection will no longer refer to / disconnect the slot. + * @param sc The scoped connection object to move from. + */ + scoped_connection(scoped_connection&& sc) noexcept; + + /** Overrides this scoped connection object moving another one. + * The current slot, if any, will be disconnect()ed before being replaced. + * The source scoped connection will no longer refer to / disconnect the slot. + * @param sc The scoped connection object to move from. + */ + scoped_connection& operator=(scoped_connection&& sc); + + /// Swap two scoped connections. + friend SIGC_API void swap(scoped_connection& sca, scoped_connection& scb) noexcept; + + /// scoped_connection disconnects the referred slot, if any, upon destruction. + ~scoped_connection(); + + /** Returns whether the connection is still active. + * @return @p false if the connection is still active. + */ + bool empty() const noexcept; + + /** Returns whether the connection is still active. + * @return @p true if the connection is still active. + */ + bool connected() const noexcept; + + /** Returns whether the connection is blocked. + * @return @p true if the connection is blocked. + */ + bool blocked() const noexcept; + + /** Sets or unsets the blocking state of this connection. + * See slot_base::block() for details. + * @param should_block Indicates whether the blocking state should be set or unset. + * @return @p true if the connection has been in blocking state before. + */ + bool block(bool should_block = true) noexcept; + + /** Unsets the blocking state of this connection. + * @return @p true if the connection has been in blocking state before. + */ + bool unblock() noexcept; + + /// Disconnects the referred slot. This will also happen upon destruction. + void disconnect(); + + /** Returns whether the connection is still active. + * @return @p true if the connection is still active. + */ + explicit operator bool() const noexcept; + + /** Releases the connection from a scoped connection object. + * The scoped connection will no longer refer to / disconnect the slot. + * @return An unscoped connection object referring to the same slot. + */ + connection release() noexcept; + +private: + sigc::connection conn_; +}; + +/// Swap two scoped connections. +SIGC_API +void swap(scoped_connection& sca, scoped_connection& scb) noexcept; + +} /* namespace sigc */ + +#endif /* SIGC_SCOPED_CONNECTION_HPP */ diff --git a/sigc++/sigc++.h b/sigc++/sigc++.h index 24d34242..0bef5489 100644 --- a/sigc++/sigc++.h +++ b/sigc++/sigc++.h @@ -1,5 +1,4 @@ -/* - * Copyright 2003, The libsigc++ Development Team +/* Copyright 2003 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,9 +11,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ #ifndef SIGCXX_SIGCXX_H @@ -24,24 +21,25 @@ * * @section description Description * - * libsigc++ provides a typesafe (at compile time) callback system for standard - * C++. It allows you to define signals and to connect those signals to any - * callback function, either a global or a member function, regardless of whether - * it is static or virtual. It also contains adaptor classes for connection of + * libsigc++ provides a typesafe (at compile time) callback system for standard + * C++. It allows you to define signals and to connect those signals to any + * callback function, either a global or a member function, regardless of whether + * it is static or virtual. It also contains adaptor classes for connection of * dissimilar callbacks. * - * For instance, see the @ref signal "Signals", @ref sigcfunctors "Functors", + * For instance, see the @ref signal "Signals", @ref sigcfunctors "Functors", * @ref slot "Slots" and @ref adaptors "Adaptors". * - * See also the - * libsigc++ tutorial, - * the libsigc++ website, and - * the Signals appendix of the Programming with gtkmm book. + * See also the + * libsigc++ tutorial, + * the libsigc++ website, and + * the + * Signals appendix of the Programming with gtkmm book. * * @section features Features * * - Compile-time typesafe callbacks (also faster than run time checks) - * - Type-safety violations report the line number correctly with template names + * - Type-safety violations report the line number correctly with template names * (no tracing template failures into headers) * - No compiler extensions or meta compilers required * - Proper handling of dynamic objects and signals (deleted objects will not @@ -62,30 +60,63 @@ * * If your source file is @c program.cc, you can compile it with: * @code - * g++ program.cc -o program `pkg-config --cflags --libs sigc++-2.0` + * g++ program.cc -o program `pkg-config --cflags --libs sigc++-3.0` + * @endcode + * If your version of g++ is not C++17-compliant by default, + * add the @c -std=c++17 option. + * + * @subsection meson Using Meson + * + * If using Meson, include the following + * in @c meson.build: + * @code + * sigc_dep = dependency('sigc++-3.0') + * program_name = 'program' + * cpp_sources = [ 'program.cc' ] + * executable(program_name, + * cpp_sources, + * dependencies: sigc_dep + * ) * @endcode * + * Your @c dependencies: keyword argument should also mention any other libraries + * that you need to use. + * + * @subsection autotools Using Autotools + * * Alternatively, if using autoconf, use the following in @c configure.ac: * @code - * PKG_CHECK_MODULES([LIBSIGC], [sigc++-2.0]) + * PKG_CHECK_MODULES([DEPS], [sigc++-3.0]) * @endcode - * Then use the generated @c LIBSIGC_CFLAGS and @c LIBSIGC_LIBS variables + * Then use the generated @c DEPS_CFLAGS and @c DEPS_LIBS variables * in the project @c Makefile.am files. For example: * @code - * program_CPPFLAGS = $(LIBSIGC_CFLAGS) - * program_LDADD = $(LIBSIGC_LIBS) + * yourprogram_CPPFLAGS = $(DEPS_CFLAGS) + * yourprogram_LDADD = $(DEPS_LIBS) * @endcode * - * @section scope Scope of Documentation + * Your @c PKG_CHECK_MODULES() call should also mention any other libraries that + * you need to use via pkg-config. + * + * @subsection cmake Using CMake + * + * If using CMake, use the following in @c CMakeList.txt: + * @code + * include(FindPkgConfig) + * pkg_check_modules(DEPS REQUIRED sigc++-3.0) + * include_directories(${DEPS_INCLUDE_DIRS}) + * target_link_libraries(yourprogram ${DEPS_LIBRARIES}) + * @endcode * - * libsigc++ contains many template functions and template classes/structs, - * some with many specializations. This reference manual does not show all - * specializations of those templates that hardly any user will use directly. + * Your @c pkg_check_modules() call should also mention any other libraries that + * you need to use via pkg-config. */ #include #include +#include #include +#include #include #include diff --git a/sigc++/signal.cc b/sigc++/signal.cc deleted file mode 100644 index 993eee4a..00000000 --- a/sigc++/signal.cc +++ /dev/null @@ -1,25 +0,0 @@ -// -*- c++ -*- -/* - * Copyright 2002, The libsigc++ Development Team - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * - */ -#include - -namespace sigc { - - -} /* sigc */ diff --git a/sigc++/signal.h b/sigc++/signal.h new file mode 100644 index 00000000..d521abc9 --- /dev/null +++ b/sigc++/signal.h @@ -0,0 +1,987 @@ +/* Copyright 2002 - 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_SIGNAL_H +#define SIGC_SIGNAL_H + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace sigc +{ + +namespace internal +{ + +/** Special iterator over sigc::internal::signal_impl's slot list that holds extra data. + * This iterators is for use in accumulators. operator*() executes + * the slot. The return value is buffered, so that in an expression + * like @code a = (*i) * (*i); @endcode the slot is executed only once. + */ +template +struct slot_iterator_buf +{ + using size_type = std::size_t; + using difference_type = std::ptrdiff_t; + using iterator_category = std::bidirectional_iterator_tag; + + // These are needed just to make this a proper C++ iterator, + // that can be used with standard C++ algorithms. + using value_type = T_result; + using reference = T_result&; + using pointer = T_result*; + + using emitter_type = T_emitter; + using slot_type = typename T_emitter::slot_type; + + using iterator_type = signal_impl::const_iterator_type; + + slot_iterator_buf() : c_(nullptr), invoked_(false) {} + + slot_iterator_buf(const iterator_type& i, const emitter_type* c) : i_(i), c_(c), invoked_(false) + { + } + + decltype(auto) operator*() const + { + if (!i_->empty() && !i_->blocked() && !invoked_) + { + r_ = (*c_)(static_cast(*i_)); + invoked_ = true; + } + return r_; + } + + slot_iterator_buf& operator++() + { + ++i_; + invoked_ = false; + return *this; + } + + slot_iterator_buf operator++(int) + { + slot_iterator_buf tmp(*this); + ++i_; + invoked_ = false; + return tmp; + } + + slot_iterator_buf& operator--() + { + --i_; + invoked_ = false; + return *this; + } + + slot_iterator_buf operator--(int) + { + slot_iterator_buf tmp(*this); + --i_; + invoked_ = false; + return tmp; + } + + bool operator==(const slot_iterator_buf& src) const + { + return (!c_ || (i_ == src.i_)); + } /* If '!c_' the iterators are empty. + * Unfortunately, empty stl iterators are not equal. + * We are forcing equality so that 'first==last' + * in the accumulator's emit function yields true. */ + + bool operator!=(const slot_iterator_buf& src) const { return (c_ && (i_ != src.i_)); } + +private: + iterator_type i_; + const emitter_type* c_; + mutable T_result r_; + mutable bool invoked_; +}; + +/** Template specialization of slot_iterator_buf for void return signals. + */ +template +struct slot_iterator_buf +{ + using size_type = std::size_t; + using difference_type = std::ptrdiff_t; + using iterator_category = std::bidirectional_iterator_tag; + + using emitter_type = T_emitter; + using slot_type = typename T_emitter::slot_type; + + using iterator_type = signal_impl::const_iterator_type; + + slot_iterator_buf() : c_(nullptr), invoked_(false) {} + + slot_iterator_buf(const iterator_type& i, const emitter_type* c) : i_(i), c_(c), invoked_(false) + { + } + + void operator*() const + { + if (!i_->empty() && !i_->blocked() && !invoked_) + { + (*c_)(static_cast(*i_)); + invoked_ = true; + } + } + + slot_iterator_buf& operator++() + { + ++i_; + invoked_ = false; + return *this; + } + + slot_iterator_buf operator++(int) + { + slot_iterator_buf tmp(*this); + ++i_; + invoked_ = false; + return tmp; + } + + slot_iterator_buf& operator--() + { + --i_; + invoked_ = false; + return *this; + } + + slot_iterator_buf operator--(int) + { + slot_iterator_buf tmp(*this); + --i_; + invoked_ = false; + return tmp; + } + + bool operator==(const slot_iterator_buf& src) const { return i_ == src.i_; } + + bool operator!=(const slot_iterator_buf& src) const { return i_ != src.i_; } + +private: + iterator_type i_; + const emitter_type* c_; + mutable bool invoked_; +}; + +/** Temporary slot list used during signal emission. + * Through evolution this class is slightly misnamed. It is now + * an index into the slot_list passed into it. It simply keeps track + * of where the end of this list was at construction, and pretends that's + * the end of your list. This way you may connect during emission without + * inadvertently entering an infinite loop, as well as make other + * modifications to the slot_list at your own risk. + */ +struct temp_slot_list +{ + using slot_list = signal_impl::slot_list; + using iterator = signal_impl::iterator_type; + using const_iterator = signal_impl::const_iterator_type; + + explicit temp_slot_list(slot_list& slots) : slots_(slots) + { + placeholder = slots_.insert(slots_.end(), slot_base()); + } + + ~temp_slot_list() { slots_.erase(placeholder); } + + iterator begin() { return slots_.begin(); } + iterator end() { return placeholder; } + const_iterator begin() const { return slots_.begin(); } + const_iterator end() const { return placeholder; } + +private: + slot_list& slots_; + slot_list::iterator placeholder; +}; + +/** Abstracts signal emission. + * This template implements the emit() function of signal_with_accumulator. + * Template specializations are available to optimize signal + * emission when no accumulator is used, for example when the template + * argument @e T_accumulator is @p void. + */ +template +struct signal_emit +{ + using self_type = signal_emit; + using slot_type = slot; + + /** Instantiates the class. + * The parameters are stored in member variables. operator()() passes + * the values on to some slot. + */ + explicit signal_emit(type_trait_take_t... a) : a_(a...) {} + + /** Invokes a slot using the buffered parameter values. + * @param slot Some slot to invoke. + * @return The slot's return value. + */ + T_return operator()(const slot_type& slot) const { return std::apply(slot, a_); } + + /** Executes a list of slots using an accumulator of type @e T_accumulator. + * The arguments are buffered in a temporary instance of signal_emit. + * @param a Arguments to be passed on to the slots. + * @return The accumulated return values of the slot invocations as processed by the accumulator. + */ + static decltype(auto) emit(const std::shared_ptr& impl, + type_trait_take_t... a) + { + using slot_iterator_buf_type = internal::slot_iterator_buf; + + T_accumulator accumulator; + + if (!impl) + return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type()); + + signal_impl_holder exec(impl); + const temp_slot_list slots(impl->slots_); + + self_type self(a...); + return accumulator( + slot_iterator_buf_type(slots.begin(), &self), slot_iterator_buf_type(slots.end(), &self)); + } + +private: + std::tuple...> a_; +}; + +/** Abstracts signal emission. + * This template specialization implements an optimized emit() + * function for the case that no accumulator is used. + */ +template +struct signal_emit +{ +private: + using slot_type = slot; + using call_type = typename slot_type::call_type; + +public: + /** Executes a list of slots. + * The arguments are passed directly on to the slots. + * The return value of the last slot invoked is returned. + * @param first An iterator pointing to the first slot in the list. + * @param last An iterator pointing to the last slot in the list. + * @param a Arguments to be passed on to the slots. + * @return The return value of the last slot invoked. + */ + static decltype(auto) emit(const std::shared_ptr& impl, + type_trait_take_t... a) + { + if (!impl || impl->slots_.empty()) + return T_return(); + + signal_impl_holder exec(impl); + T_return r_ = T_return(); + + // Use this scope to make sure that "slots" is destroyed before "exec" is destroyed. + // This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249 + { + const temp_slot_list slots(impl->slots_); + auto it = slots.begin(); + for (; it != slots.end(); ++it) + { + if (!it->empty() && !it->blocked()) + break; + } + + if (it == slots.end()) + { + // note that 'T_return r_();' doesn't work => define 'r_' after this line + // and initialize as follows: + return T_return(); + } + + r_ = (sigc::internal::function_pointer_cast(it->rep_->call_))(it->rep_, a...); + for (++it; it != slots.end(); ++it) + { + if (it->empty() || it->blocked()) + continue; + r_ = (sigc::internal::function_pointer_cast(it->rep_->call_))(it->rep_, a...); + } + } + + return r_; + } +}; + +/** Abstracts signal emission. + * This template specialization implements an optimized emit() + * function for the case that no accumulator is used and the + * return type is @p void. + */ +template +struct signal_emit +{ +private: + using slot_type = slot; + using call_type = typename slot_type::call_type; + +public: + /** Executes a list of slots using an accumulator of type @e T_accumulator. + * The arguments are passed directly on to the slots. + * @param a Arguments to be passed on to the slots. + */ + static decltype(auto) emit(const std::shared_ptr& impl, + type_trait_take_t... a) + { + if (!impl || impl->slots_.empty()) + return; + signal_impl_holder exec(impl); + const temp_slot_list slots(impl->slots_); + + for (const auto& slot : slots) + { + if (slot.empty() || slot.blocked()) + continue; + + (sigc::internal::function_pointer_cast(slot.rep_->call_))( + slot.rep_, std::forward>(a)...); + } + } +}; + +} /* namespace internal */ + +/** Signal declaration. + * %signal_with_accumulator can be used to connect() slots that are invoked + * during subsequent calls to emit(). Any functor or slot + * can be passed into connect() or connect_first(). It is converted into a slot + * implicitly. + * + * If you want to connect one signal to another, use make_slot() + * to retrieve a functor that emits the signal when invoked. + * + * Be careful if you directly pass one signal into the connect() or + * connect_first() method of another: a shallow copy of the signal is made and + * the signal's slots are not disconnected until both the signal + * and its clone are destroyed, which is probably not what you want! + * + * The following template arguments are used: + * - @e T_return The desired return type for the emit() function (may be overridden by the + * accumulator). + * - @e T_arg Argument types used in the definition of emit(). + * - @e T_accumulator The accumulator type used for emission. The default + * @p void means that no accumulator should be used, for example if signal + * emission returns the return value of the last slot invoked. + * + * @ingroup signal + */ +template +class signal_with_accumulator : public signal_base +{ +public: + using slot_type = slot; + + /** Add a slot at the end of the list of slots. + * Any functor or slot may be passed into %connect(). + * It will be converted into a slot implicitly. + * The returned connection may be stored for disconnection + * of the slot at some later point. It stays valid until + * the slot is disconnected from the signal. + * std::function<> and C++11 lambda expressions are functors. + * These are examples of functors that can be connected to a signal. + * + * %std::bind() creates a functor, but this functor typically has an + * %operator()() which is a variadic template. + * Our functor_trait can't deduce the result type + * of such a functor. If you first assign the return value of %std::bind() + * to a std::function, you can connect the std::function to a signal. + * + * @param slot_ The slot to add to the list of slots. + * @return A connection. + */ + connection connect(const slot_type& slot_) + { + auto iter = signal_base::connect(slot_); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Add a slot at the end of the list of slots. + * @see connect(const slot_type& slot_). + * + * @newin{2,8} + */ + connection connect(slot_type&& slot_) + { + auto iter = signal_base::connect(std::move(slot_)); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Add a slot at the beginning of the list of slots. + * Any functor or slot may be passed into %connect_first(). + * It will be converted into a slot implicitly. + * The returned connection may be stored for disconnection + * of the slot at some later point. It stays valid until + * the slot is disconnected from the signal. + * std::function<> and C++11 lambda expressions are functors. + * These are examples of functors that can be connected to a signal. + * + * %std::bind() creates a functor, but this functor typically has an + * %operator()() which is a variadic template. + * Our functor_trait can't deduce the result type + * of such a functor. If you first assign the return value of %std::bind() + * to a std::function, you can connect the std::function to a signal. + * + * @param slot_ The slot to add to the list of slots. + * @return A connection. + * + * @newin{3,6} + */ + connection connect_first(const slot_type& slot_) + { + auto iter = signal_base::connect_first(slot_); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Add a slot at the beginning of the list of slots. + * @see connect_first(const slot_type& slot_). + * + * @newin{3,6} + */ + connection connect_first(slot_type&& slot_) + { + auto iter = signal_base::connect_first(std::move(slot_)); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Triggers the emission of the signal. + * During signal emission all slots that have been connected + * to the signal are invoked unless they are manually set into + * a blocking state. The parameters are passed on to the slots. + * If @e T_accumulated is not @p void, an accumulator of this type + * is used to process the return values of the slot invocations. + * Otherwise, the return value of the last slot invoked is returned. + * @param a Arguments to be passed on to the slots. + * @return The accumulated return values of the slot invocations. + */ + decltype(auto) emit(type_trait_take_t... a) const + { + using emitter_type = internal::signal_emit; + return emitter_type::emit(impl_, std::forward>(a)...); + } + + /** Triggers the emission of the signal (see emit()). */ + decltype(auto) operator()(type_trait_take_t... a) const + { + return emit(std::forward>(a)...); + } + + /** Creates a functor that calls emit() on this signal. + * + * @note %sigc::signal does not derive from sigc::trackable. + * If you connect the returned functor that calls %emit() on signal1, + * to another signal (signal2) and then delete signal1, you must manually + * disconnect signal1 from signal2 before you delete signal1. + * Alternatively, make a slot of a sigc::trackable_signal. + * + * @code + * sigc::mem_fun(mysignal, &sigc::signal_with_accumulator::emit) + * @endcode + * yields the same result. + * @return A functor that calls emit() on this signal. + */ + decltype(auto) make_slot() const + { + // TODO: Instead use std::invoke_result<> on the static emitter_type::emit() + using result_type = + typename internal::member_method_result::type; + return bound_mem_functor...) + const, + type_trait_take_t...>(*this, &signal_with_accumulator::emit); + } + + signal_with_accumulator() = default; + + signal_with_accumulator(const signal_with_accumulator& src) : signal_base(src) {} + + signal_with_accumulator(signal_with_accumulator&& src) : signal_base(std::move(src)) {} + + signal_with_accumulator& operator=(const signal_with_accumulator& src) + { + signal_base::operator=(src); + return *this; + } + + signal_with_accumulator& operator=(signal_with_accumulator&& src) + { + signal_base::operator=(std::move(src)); + return *this; + } +}; + +/** signal can be used to connect() slots that are invoked + * during subsequent calls to emit(). Any functor or slot + * can be passed into connect() or connect_first(). It is converted into a slot + * implicitly. + * + * If you want to connect one signal to another, use make_slot() + * to retrieve a functor that emits the signal when invoked. + * + * Be careful if you directly pass one signal into the connect() or + * connect_first() method of another: a shallow copy of the signal is made and + * the signal's slots are not disconnected until both the signal + * and its clone are destroyed, which is probably not what you want! + * + * The template arguments determine the function signature of + * the emit() function: + * - @e T_return The desired return type of the emit() function. + * - @e T_arg Argument types used in + * the definition of emit(). + * + * For instance, to declare a signal whose connected slot returns void and takes + * two parameters of bool and int: + * @code + * sigc::signal some_signal; + * @endcode + * + * To specify an accumulator type the nested class signal::accumulated can be used. + * + * @par Example: + * @code + * void foo(int) {} + * sigc::signal sig; + * sig.connect(sigc::ptr_fun(&foo)); + * sig.emit(19); + * @endcode + * + * @ingroup signal + */ +#ifndef DOXYGEN_SHOULD_SKIP_THIS +template +class signal final { + static_assert(sizeof...(T_arg) < 0, "The signal syntax has been removed. Use the signal syntax."); +}; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +template +class signal : public signal_with_accumulator +{ +public: + using accumulator_type = void; + + /** Like @ref sigc::signal "sigc::signal" but the additional + * template parameter @e T_accumulator defines the accumulator type that should be used. + * + * An accumulator is a functor that uses a pair of special iterators + * to step through a list of slots and calculate a return value + * from the results of the slot invocations. The iterators' operator*() + * executes the slot. The return value is buffered, so that in an expression + * like @code a = (*i) * (*i); @endcode the slot is executed only once. + * + * @par Example 1: + * This accumulator calculates the arithmetic mean value: + * @code + * struct arithmetic_mean_accumulator + * { + * template + * double operator()(T_iterator first, T_iterator last) const + * { + * double value_ = 0; + * int n_ = 0; + * for (; first != last; ++first, ++n_) + * value_ += *first; + * return value_ / n_; + * } + * }; + * @endcode + * + * @par Example 2: + * This accumulator stops signal emission when a slot returns zero: + * @code + * struct interruptable_accumulator + * { + * template + * bool operator()(T_iterator first, T_iterator last) const + * { + * for (; first != last; ++first, ++n_) + * if (!*first) return false; + * return true; + * } + * }; + * @endcode + * + * @ingroup signal + */ + template + class accumulated : public signal_with_accumulator + { + public: + accumulated() = default; + accumulated(const accumulated& src) + : signal_with_accumulator(src) + { + } + }; + + signal() = default; + + signal(const signal& src) : signal_with_accumulator(src) {} + + signal(signal&& src) + : signal_with_accumulator(std::move(src)) + { + } + + signal& operator=(const signal& src) + { + signal_with_accumulator::operator=(src); + return *this; + } + + signal& operator=(signal&& src) + { + signal_with_accumulator::operator=(std::move(src)); + return *this; + } +}; + +// TODO: When we can break ABI, let signal_base derive from trackable, as in sigc++2, +// and delete trackable_signal_with_accumulator and trackable_signal. +// https://github.com/libsigcplusplus/libsigcplusplus/issues/80 + +/** Signal declaration. + * %trackable_signal_with_accumulator can be used to connect() slots that are invoked + * during subsequent calls to emit(). Any functor or slot + * can be passed into connect() or connect_first(). It is converted into a slot + * implicitly. + * + * If you want to connect one signal to another, use make_slot() + * to retrieve a functor that emits the signal when invoked. + * + * Be careful if you directly pass one signal into the connect() or + * connect_first() method of another: a shallow copy of the signal is made and + * the signal's slots are not disconnected until both the signal + * and its clone are destroyed, which is probably not what you want! + * + * The following template arguments are used: + * - @e T_return The desired return type for the emit() function (may be overridden by the + * accumulator). + * - @e T_arg Argument types used in the definition of emit(). + * - @e T_accumulator The accumulator type used for emission. The default + * @p void means that no accumulator should be used, for example if signal + * emission returns the return value of the last slot invoked. + * + * @newin{3,4} + * + * @ingroup signal + */ +template +class trackable_signal_with_accumulator +: public signal_base +, public trackable +{ +public: + using slot_type = slot; + + /** Add a slot at the end of the list of slots. + * Any functor or slot may be passed into %connect(). + * It will be converted into a slot implicitly. + * The returned connection may be stored for disconnection + * of the slot at some later point. It stays valid until + * the slot is disconnected from the signal. + * std::function<> and C++11 lambda expressions are functors. + * These are examples of functors that can be connected to a signal. + * + * %std::bind() creates a functor, but this functor typically has an + * %operator()() which is a variadic template. + * Our functor_trait can't deduce the result type + * of such a functor. If you first assign the return value of %std::bind() + * to a std::function, you can connect the std::function to a signal. + * + * @param slot_ The slot to add to the list of slots. + * @return A connection. + */ + connection connect(const slot_type& slot_) + { + auto iter = signal_base::connect(slot_); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Add a slot at the end of the list of slots. + * @see connect(const slot_type& slot_). + */ + connection connect(slot_type&& slot_) + { + auto iter = signal_base::connect(std::move(slot_)); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Add a slot at the beginning of the list of slots. + * Any functor or slot may be passed into %connect_first(). + * It will be converted into a slot implicitly. + * The returned connection may be stored for disconnection + * of the slot at some later point. It stays valid until + * the slot is disconnected from the signal. + * std::function<> and C++11 lambda expressions are functors. + * These are examples of functors that can be connected to a signal. + * + * %std::bind() creates a functor, but this functor typically has an + * %operator()() which is a variadic template. + * Our functor_trait can't deduce the result type + * of such a functor. If you first assign the return value of %std::bind() + * to a std::function, you can connect the std::function to a signal. + * + * @param slot_ The slot to add to the list of slots. + * @return A connection. + * + * @newin{3,6} + */ + connection connect_first(const slot_type& slot_) + { + auto iter = signal_base::connect_first(slot_); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Add a slot at the beginning of the list of slots. + * @see connect_first(const slot_type& slot_). + * + * @newin{3,6} + */ + connection connect_first(slot_type&& slot_) + { + auto iter = signal_base::connect_first(std::move(slot_)); + auto& slot_base = *iter; + return connection(slot_base); + } + + /** Triggers the emission of the signal. + * During signal emission all slots that have been connected + * to the signal are invoked unless they are manually set into + * a blocking state. The parameters are passed on to the slots. + * If @e T_accumulated is not @p void, an accumulator of this type + * is used to process the return values of the slot invocations. + * Otherwise, the return value of the last slot invoked is returned. + * @param a Arguments to be passed on to the slots. + * @return The accumulated return values of the slot invocations. + */ + decltype(auto) emit(type_trait_take_t... a) const + { + using emitter_type = internal::signal_emit; + return emitter_type::emit(impl_, std::forward>(a)...); + } + + /** Triggers the emission of the signal (see emit()). */ + decltype(auto) operator()(type_trait_take_t... a) const + { + return emit(std::forward>(a)...); + } + + /** Creates a functor that calls emit() on this signal. + * + * @code + * sigc::mem_fun(mysignal, &sigc::trackable_signal_with_accumulator::emit) + * @endcode + * yields the same result. + * @return A functor that calls emit() on this signal. + */ + decltype(auto) make_slot() const + { + // TODO: Instead use std::invoke_result<> on the static emitter_type::emit() + using result_type = typename internal::member_method_result< + decltype(&trackable_signal_with_accumulator::emit)>::type; + return bound_mem_functor...) const, + type_trait_take_t...>(*this, &trackable_signal_with_accumulator::emit); + } + + trackable_signal_with_accumulator() = default; + + trackable_signal_with_accumulator(const trackable_signal_with_accumulator& src) + : signal_base(src), trackable(src) + { + } + + trackable_signal_with_accumulator(trackable_signal_with_accumulator&& src) + : signal_base(std::move(src)), trackable(std::move(src)) + { + } + + trackable_signal_with_accumulator& operator=(const trackable_signal_with_accumulator& src) + { + signal_base::operator=(src); + // Don't call trackable::operator=(src). + // It calls notify_callbacks(). This signal is not destroyed. + return *this; + } + + trackable_signal_with_accumulator& operator=(trackable_signal_with_accumulator&& src) + { + signal_base::operator=(std::move(src)); + if (src.impl_ != impl_) + src.notify_callbacks(); + // Don't call trackable::operator=(std::move(src)). + // It calls notify_callbacks(). This signal is not destroyed. + return *this; + } +}; + +/** %trackable_signal can be used to connect() slots that are invoked + * during subsequent calls to emit(). Any functor or slot + * can be passed into connect() or connect_first(). It is converted into a slot + * implicitly. + * + * If you want to connect one signal to another, use make_slot() + * to retrieve a functor that emits the signal when invoked. + * + * Be careful if you directly pass one signal into the connect() or + * connect_first() method of another: a shallow copy of the signal is made and + * the signal's slots are not disconnected until both the signal + * and its clone are destroyed, which is probably not what you want! + * + * The template arguments determine the function signature of + * the emit() function: + * - @e T_return The desired return type of the emit() function. + * - @e T_arg Argument types used in + * the definition of emit(). + * + * For instance, to declare a %trackable_signal whose connected slot returns void and takes + * two parameters of bool and int: + * @code + * sigc::trackable_signal some_signal; + * @endcode + * + * To specify an accumulator type the nested class trackable_signal::accumulated can be used. + * + * @par Example: + * @code + * void foo(int) {} + * sigc::trackable_signal sig; + * sig.connect(sigc::ptr_fun(&foo)); + * sig.emit(19); + * @endcode + * + * @newin{3,4} + * + * @ingroup signal + */ +#ifndef DOXYGEN_SHOULD_SKIP_THIS +template +class trackable_signal; +#endif // DOXYGEN_SHOULD_SKIP_THIS + +template +class trackable_signal +: public trackable_signal_with_accumulator +{ +public: + using accumulator_type = void; + + /** Like @ref sigc::trackable_signal "sigc::trackable_signal" + * but the additional template parameter @e T_accumulator defines the accumulator + * type that should be used. + * + * An accumulator is a functor that uses a pair of special iterators + * to step through a list of slots and calculate a return value + * from the results of the slot invocations. The iterators' operator*() + * executes the slot. The return value is buffered, so that in an expression + * like @code a = (*i) * (*i); @endcode the slot is executed only once. + * + * @par Example 1: + * This accumulator calculates the arithmetic mean value: + * @code + * struct arithmetic_mean_accumulator + * { + * template + * double operator()(T_iterator first, T_iterator last) const + * { + * double value_ = 0; + * int n_ = 0; + * for (; first != last; ++first, ++n_) + * value_ += *first; + * return value_ / n_; + * } + * }; + * @endcode + * + * @par Example 2: + * This accumulator stops signal emission when a slot returns zero: + * @code + * struct interruptable_accumulator + * { + * template + * bool operator()(T_iterator first, T_iterator last) const + * { + * for (; first != last; ++first, ++n_) + * if (!*first) return false; + * return true; + * } + * }; + * @endcode + * + * @newin{3,4} + * + * @ingroup signal + */ + template + class accumulated : public trackable_signal_with_accumulator + { + public: + accumulated() = default; + accumulated(const accumulated& src) + : trackable_signal_with_accumulator(src) + { + } + }; + + trackable_signal() = default; + + trackable_signal(const trackable_signal& src) + : trackable_signal_with_accumulator(src) + { + } + + trackable_signal(trackable_signal&& src) + : trackable_signal_with_accumulator(std::move(src)) + { + } + + trackable_signal& operator=(const trackable_signal& src) + { + trackable_signal_with_accumulator::operator=(src); + return *this; + } + + trackable_signal& operator=(trackable_signal&& src) + { + trackable_signal_with_accumulator::operator=( + std::move(src)); + return *this; + } +}; + +} /* namespace sigc */ + +#endif /* SIGC_SIGNAL_H */ diff --git a/sigc++/signal_base.cc b/sigc++/signal_base.cc index cc8342bb..617bb774 100644 --- a/sigc++/signal_base.cc +++ b/sigc++/signal_base.cc @@ -1,5 +1,4 @@ -/* - * Copyright 2003, The libsigc++ Development Team +/* Copyright 2003 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,67 +11,91 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * License along with this library; if not, see . */ #include #include // std::unique_ptr -namespace sigc { -namespace internal { +namespace sigc +{ +namespace internal +{ // Data sent from signal_impl::insert() to slot_rep::set_parent() when a slot is -// connected, and then sent from slot_rep::disconnect() to signal_impl::notify() +// connected, and then sent from slot_rep::disconnect() to +// signal_impl::notify_self_and_iter_of_invalidated_slot() // when the slot is disconnected. Bug 167714. -struct self_and_iter +struct self_and_iter : public notifiable { - signal_impl* self_; - signal_impl::iterator_type iter_; + const std::weak_ptr self_; + const signal_impl::iterator_type iter_; - self_and_iter(signal_impl* self, signal_impl::iterator_type iter) - : self_(self), iter_(iter) {} + self_and_iter(const std::weak_ptr& self, const signal_impl::iterator_type& iter) + : self_(self), iter_(iter) + { + } }; -signal_impl::signal_impl() -: ref_count_(0), exec_count_(0), deferred_(false) -{} +signal_impl::signal_impl() : exec_count_(0), deferred_(false) {} + +signal_impl::~signal_impl() +{ + // Disconnect all slots before *this is deleted. + clear(); +} // only MSVC needs this to guarantee that all new/delete are executed from the DLL module #ifdef SIGC_NEW_DELETE_IN_LIBRARY_ONLY -void* signal_impl::operator new(size_t size_) +void* +signal_impl::operator new(size_t size_) { return malloc(size_); } -void signal_impl::operator delete(void* p) +void +signal_impl::operator delete(void* p) { free(p); } #endif -void signal_impl::clear() +void +signal_impl::clear() { - // Don't let signal_impl::notify() erase the slots. It would invalidate the - // iterator in the following loop. + // Don't let signal_impl::notify_self_and_iter_of_invalidated_slot() erase the slots. + // It would invalidate the iterator in the following loop. + // Don't call shared_from_this() here. clear() is called from the destructor. + // When the destructor is executing, shared_ptr's use_count has reached 0, + // and it's no longer possible to get a shared_ptr to this. + const bool during_signal_emission = exec_count_ > 0; const bool saved_deferred = deferred_; - signal_exec exec(this); + signal_impl_exec_holder exec(this); // Disconnect all connected slots before they are deleted. - // signal_impl::notify() will be called and delete the self_and_iter structs. + // signal_impl::notify_self_and_iter_of_invalidated_slot() will be called and + // delete the self_and_iter structs. for (auto& slot : slots_) slot.disconnect(); - deferred_ = saved_deferred; - - slots_.clear(); + // Don't clear slots_ during signal emission. Provided deferred_ is true, + // sweep() will be called from ~signal_impl_holder() after signal emission, + // and it will erase all disconnected slots. + // https://bugzilla.gnome.org/show_bug.cgi?id=784550 + if (!during_signal_emission) + { + deferred_ = saved_deferred; + slots_.clear(); + } } -signal_impl::size_type signal_impl::size() const noexcept +signal_impl::size_type +signal_impl::size() const noexcept { return slots_.size(); } -bool signal_impl::blocked() const noexcept +bool +signal_impl::blocked() const noexcept { for (const auto& slot : const_cast&>(slots_)) { @@ -82,7 +105,8 @@ bool signal_impl::blocked() const noexcept return true; } -void signal_impl::block(bool should_block) noexcept +void +signal_impl::block(bool should_block) noexcept { for (auto& slot : slots_) { @@ -90,213 +114,214 @@ void signal_impl::block(bool should_block) noexcept } } -signal_impl::iterator_type signal_impl::connect(const slot_base& slot_) +signal_impl::iterator_type +signal_impl::connect(const slot_base& slot_) { return insert(slots_.end(), slot_); } -signal_impl::iterator_type signal_impl::connect(slot_base&& slot_) +signal_impl::iterator_type +signal_impl::connect(slot_base&& slot_) { return insert(slots_.end(), std::move(slot_)); } -signal_impl::iterator_type signal_impl::erase(iterator_type i) +signal_impl::iterator_type +signal_impl::connect_first(const slot_base& slot_) { - // Don't let signal_impl::notify() erase the slot. It would be more - // difficult to get the correct return value from signal_impl::erase(). - const bool saved_deferred = deferred_; - signal_exec exec(this); - - // Disconnect the slot before it is deleted. - // signal_impl::notify() will be called and delete the self_and_iter struct. - i->disconnect(); + return insert(slots_.begin(), slot_); +} - deferred_ = saved_deferred; +signal_impl::iterator_type +signal_impl::connect_first(slot_base&& slot_) +{ + return insert(slots_.begin(), std::move(slot_)); +} - return slots_.erase(i); +void +signal_impl::add_notification_to_iter(const signal_impl::iterator_type& iter) +{ + auto si = new self_and_iter(shared_from_this(), iter); + iter->set_parent(si, &signal_impl::notify_self_and_iter_of_invalidated_slot); } - -signal_impl::iterator_type signal_impl::insert(signal_impl::iterator_type i, const slot_base& slot_) + +signal_impl::iterator_type +signal_impl::insert(signal_impl::iterator_type i, const slot_base& slot_) { - auto temp = slots_.insert(i, slot_); - auto si = new self_and_iter(this, temp); - temp->set_parent(si, ¬ify); - return temp; + auto iter = slots_.insert(i, slot_); + add_notification_to_iter(iter); + return iter; } -signal_impl::iterator_type signal_impl::insert(signal_impl::iterator_type i, slot_base&& slot_) +signal_impl::iterator_type +signal_impl::insert(signal_impl::iterator_type i, slot_base&& slot_) { - auto temp = slots_.insert(i, std::move(slot_)); - auto si = new self_and_iter(this, temp); - temp->set_parent(si, ¬ify); - return temp; + auto iter = slots_.insert(i, std::move(slot_)); + add_notification_to_iter(iter); + return iter; } -void signal_impl::sweep() +void +signal_impl::sweep() { // The deletion of a slot may cause the deletion of a signal_base, // a decrementation of ref_count_, and the deletion of this. - // In that case, the deletion of this is deferred to ~signal_exec(). - signal_exec exec(this); + // In that case, the deletion of this is deferred to ~signal_impl_holder(). + signal_impl_holder exec(shared_from_this()); deferred_ = false; auto i = slots_.begin(); while (i != slots_.end()) + { if ((*i).empty()) i = slots_.erase(i); else ++i; + } } -//static -void* signal_impl::notify(void* d) +// static +void +signal_impl::notify_self_and_iter_of_invalidated_slot(notifiable* d) { std::unique_ptr si(static_cast(d)); + auto self = si->self_.lock(); + if (!self) + { + // The signal_impl object is being deleted. The use_count has reached 0. + // Nothing to do here. exec_count_ > 0 and clear() will restore deferred_. + return; + } - if (si->self_->exec_count_ == 0) + if (self->exec_count_ == 0) { // The deletion of a slot may cause the deletion of a signal_base, // a decrementation of si->self_->ref_count_, and the deletion of si->self_. - // In that case, the deletion of si->self_ is deferred to ~signal_exec(). - signal_exec exec(si->self_); - si->self_->slots_.erase(si->iter_); + // In that case, the deletion of si->self_ is deferred to ~signal_impl_holder(). + // https://bugzilla.gnome.org/show_bug.cgi?id=564005#c24 + signal_impl_holder exec(self); + self->slots_.erase(si->iter_); + } + else + { + // This is occurring during signal emission or slot erasure. + // => sweep() will be called from ~signal_impl_holder() after signal emission. + // This is safer because we don't have to care about our + // iterators in emit() and clear(). + self->deferred_ = true; } - else // This is occuring during signal emission or slot erasure. - si->self_->deferred_ = true; // => sweep() will be called from ~signal_exec() after signal emission. - return nullptr; // This is safer because we don't have to care about our - // iterators in emit(), clear(), and erase(). } } /* namespace internal */ -signal_base::signal_base() noexcept -: impl_(nullptr) -{} +signal_base::signal_base() noexcept {} -signal_base::signal_base(const signal_base& src) noexcept -: trackable(), - impl_(src.impl()) -{ - impl_->reference(); -} +signal_base::signal_base(const signal_base& src) noexcept : impl_(src.impl()) {} -signal_base::signal_base(signal_base&& src) -: trackable(std::move(src)), - impl_(std::move(src.impl_)) +signal_base::signal_base(signal_base&& src) : impl_(std::move(src.impl_)) { src.impl_ = nullptr; } -signal_base::~signal_base() -{ - if (impl_) - { - // Disconnect all slots before impl_ is deleted. - // TODO: Move the signal_impl::clear() call to ~signal_impl() when ABI can be broken. - if (impl_->ref_count_ == 1) - impl_->clear(); - - impl_->unreference(); - } -} +signal_base::~signal_base() {} -void signal_base::clear() +void +signal_base::clear() { if (impl_) impl_->clear(); } -signal_base::size_type signal_base::size() const noexcept +signal_base::size_type +signal_base::size() const noexcept { return (impl_ ? impl_->size() : 0); } -bool signal_base::blocked() const noexcept +bool +signal_base::blocked() const noexcept { return (impl_ ? impl_->blocked() : true); } -void signal_base::block(bool should_block) noexcept +void +signal_base::block(bool should_block) noexcept { if (impl_) impl_->block(should_block); } -void signal_base::unblock() noexcept +void +signal_base::unblock() noexcept { if (impl_) impl_->block(false); } -signal_base::iterator_type signal_base::connect(const slot_base& slot_) +signal_base::iterator_type +signal_base::connect(const slot_base& slot_) { return impl()->connect(slot_); } -signal_base::iterator_type signal_base::connect(slot_base&& slot_) +signal_base::iterator_type +signal_base::connect(slot_base&& slot_) { return impl()->connect(std::move(slot_)); } -signal_base::iterator_type signal_base::insert(iterator_type i, const slot_base& slot_) +signal_base::iterator_type +signal_base::connect_first(const slot_base& slot_) { - return impl()->insert(i, slot_); + return impl()->connect_first(slot_); } -signal_base::iterator_type signal_base::insert(iterator_type i, slot_base&& slot_) +signal_base::iterator_type +signal_base::connect_first(slot_base&& slot_) { - return impl()->insert(i, std::move(slot_)); + return impl()->connect_first(std::move(slot_)); } -signal_base::iterator_type signal_base::erase(iterator_type i) +signal_base::iterator_type +signal_base::insert(iterator_type i, const slot_base& slot_) { - return impl()->erase(i); + return impl()->insert(i, slot_); } -signal_base& signal_base::operator=(const signal_base& src) +signal_base::iterator_type +signal_base::insert(iterator_type i, slot_base&& slot_) { - if (src.impl_ == impl_) return *this; + return impl()->insert(i, std::move(slot_)); +} - if (impl_) - { - // Disconnect all slots before impl_ is deleted. - // TODO: Move the signal_impl::clear() call to ~signal_impl() when ABI can be broken. - if (impl_->ref_count_ == 1) - impl_->clear(); +signal_base& +signal_base::operator=(const signal_base& src) +{ + if (src.impl_ == impl_) + return *this; - impl_->unreference(); - } impl_ = src.impl(); - impl_->reference(); return *this; } -signal_base& signal_base::operator=(signal_base&& src) +signal_base& +signal_base::operator=(signal_base&& src) { - if (src.impl_ == impl_) return *this; + if (src.impl_ == impl_) + return *this; - if (impl_) - { - // Disconnect all slots before impl_ is deleted. - // TODO: Move the signal_impl::clear() call to ~signal_impl() when ABI can be broken. - if (impl_->ref_count_ == 1) - impl_->clear(); - - impl_->unreference(); - } - - src.notify_callbacks(); impl_ = src.impl_; src.impl_ = nullptr; return *this; } -internal::signal_impl* signal_base::impl() const +std::shared_ptr +signal_base::impl() const { - if (!impl_) { - impl_ = new internal::signal_impl; - impl_->reference(); // start with a reference count of 1 + if (!impl_) + { + impl_ = std::make_shared(); } return impl_; } diff --git a/sigc++/signal_base.h b/sigc++/signal_base.h index f50a6cb7..8da25508 100644 --- a/sigc++/signal_base.h +++ b/sigc++/signal_base.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,18 +11,17 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * License along with this library; if not, see . */ -#ifndef _SIGC_SIGNAL_BASE_H_ -#define _SIGC_SIGNAL_BASE_H_ +#ifndef SIGC_SIGNAL_BASE_H +#define SIGC_SIGNAL_BASE_H #include #include +#include //For std::shared_ptr<> #include #include -#include #include #include @@ -36,20 +34,21 @@ namespace internal { /** Implementation of the signal interface. - * signal_impl manages a list of slots. When a slot becomes - * invalid (because some referred object dies), notify() is executed. - * notify() either calls slots_.erase() directly or defers the execution of - * erase() to sweep() when the signal is being emitted. sweep() removes all - * invalid slots from the list. + * signal_impl manages a list of slots. When a slot becomes invalid (because some + * referred object dies), notify_self_and_iter_of_invalidated_slot() is executed. + * notify_self_and_iter_of_invalidated_slot() either calls slots_.erase() directly + * or defers the execution of erase() to sweep() when the signal is being emitted. + * sweep() removes all invalid slots from the list. */ -struct SIGC_API signal_impl +struct SIGC_API signal_impl : public std::enable_shared_from_this { - typedef std::size_t size_type; - typedef std::list slot_list; - typedef slot_list::iterator iterator_type; - typedef slot_list::const_iterator const_iterator_type; + using size_type = std::size_t; + using slot_list = std::list; + using iterator_type = slot_list::iterator; + using const_iterator_type = slot_list::const_iterator; signal_impl(); + ~signal_impl(); signal_impl(const signal_impl& src) = delete; signal_impl& operator=(const signal_impl& src) = delete; @@ -57,41 +56,29 @@ struct SIGC_API signal_impl signal_impl(signal_impl&& src) = delete; signal_impl& operator=(signal_impl&& src) = delete; - // only MSVC needs this to guarantee that all new/delete are executed from the DLL module +// only MSVC needs this to guarantee that all new/delete are executed from the DLL module #ifdef SIGC_NEW_DELETE_IN_LIBRARY_ONLY void* operator new(size_t size_); void operator delete(void* p); #endif - /// Increments the reference counter. - inline void reference() noexcept - { ++ref_count_; } - /// Increments the reference and execution counter. - inline void reference_exec() noexcept - { ++ref_count_; ++exec_count_; } - - /** Decrements the reference counter. - * The object is deleted when the reference counter reaches zero. - */ - inline void unreference() - { if (!(--ref_count_)) delete this; } + inline void reference_exec() noexcept { ++exec_count_; } /** Decrements the reference and execution counter. * Invokes sweep() if the execution counter reaches zero and the * removal of one or more slots has been deferred. */ inline void unreference_exec() - { - if (!(--ref_count_)) delete this; - else if (!(--exec_count_) && deferred_) sweep(); - } + { + if (!(--exec_count_) && deferred_) + sweep(); + } /** Returns whether the list of slots is empty. * @return @p true if the list of slots is empty. */ - inline bool empty() const noexcept - { return slots_.empty(); } + inline bool empty() const noexcept { return slots_.empty(); } /// Empties the list of slots. void clear(); @@ -120,13 +107,13 @@ struct SIGC_API signal_impl */ void block(bool should_block = true) noexcept; - /** Adds a slot at the bottom of the list of slots. + /** Adds a slot at the end of the list of slots. * @param slot_ The slot to add to the list of slots. * @return An iterator pointing to the new slot in the list. */ iterator_type connect(const slot_base& slot_); - /** Adds a slot at the bottom of the list of slots. + /** Adds a slot at the end of the list of slots. * @param slot_ The slot to add to the list of slots. * @return An iterator pointing to the new slot in the list. * @@ -134,6 +121,22 @@ struct SIGC_API signal_impl */ iterator_type connect(slot_base&& slot_); + /** Adds a slot at the beginning of the list of slots. + * @param slot_ The slot to add to the list of slots. + * @return An iterator pointing to the new slot in the list. + * + * @newin{3,6} + */ + iterator_type connect_first(const slot_base& slot_); + + /** Adds a slot at the beginning of the list of slots. + * @param slot_ The slot to add to the list of slots. + * @return An iterator pointing to the new slot in the list. + * + * @newin{3,6} + */ + iterator_type connect_first(slot_base&& slot_); + /** Adds a slot at the given position into the list of slots. * @param i An iterator indicating the position where @p slot_ should be inserted. * @param slot_ The slot to add to the list of slots. @@ -150,15 +153,10 @@ struct SIGC_API signal_impl */ iterator_type insert(iterator_type i, slot_base&& slot_); - /** Removes the slot at the given position from the list of slots. - * @param i An iterator pointing to the slot to be removed. - * @return An iterator pointing to the slot in the list after the one removed. - */ - iterator_type erase(iterator_type i); - /// Removes invalid slots from the list of slots. void sweep(); +private: /** Callback that is executed when some slot becomes invalid. * This callback is registered in every slot when inserted into * the list of slots. It is executed when a slot becomes invalid @@ -167,13 +165,15 @@ struct SIGC_API signal_impl * erase() to sweep() when the signal is being emitted. * @param d A local structure, created in insert(). */ - static void* notify(void* d); + static void notify_self_and_iter_of_invalidated_slot(notifiable* d); - /** Reference counter. - * The object is destroyed when @em ref_count_ reaches zero. - */ - short ref_count_; + void add_notification_to_iter(const signal_impl::iterator_type& iter); + +public: + /// The list of slots. + std::list slots_; +private: /** Execution counter. * Indicates whether the signal is being emitted. */ @@ -181,68 +181,61 @@ struct SIGC_API signal_impl /// Indicates whether the execution of sweep() is being deferred. bool deferred_; - - /// The list of slots. - std::list slots_; }; -/// Exception safe sweeper for cleaning up invalid slots on the slot list. -struct SIGC_API signal_exec +struct SIGC_API signal_impl_exec_holder { - /// The parent sigc::signal_impl object. - signal_impl* sig_; - - /** Increments the reference and execution counter of the parent sigc::signal_impl object. + /** Increments the execution counter of the parent sigc::signal_impl object. * @param sig The parent sigc::signal_impl object. */ - inline signal_exec(const signal_impl* sig) noexcept - : sig_(const_cast(sig) ) - { sig_->reference_exec(); } + inline explicit signal_impl_exec_holder(signal_impl* sig) noexcept : sig_(sig) + { + sig_->reference_exec(); + } + + signal_impl_exec_holder(const signal_impl_exec_holder& src) = delete; + signal_impl_exec_holder operator=(const signal_impl_exec_holder& src) = delete; + + signal_impl_exec_holder(signal_impl_exec_holder&& src) = delete; + signal_impl_exec_holder operator=(signal_impl_exec_holder&& src) = delete; /// Decrements the reference and execution counter of the parent sigc::signal_impl object. - inline ~signal_exec() - { sig_->unreference_exec(); } + inline ~signal_impl_exec_holder() { sig_->unreference_exec(); } + +protected: + /// The parent sigc::signal_impl object. + signal_impl* sig_; }; -/** Temporary slot list used during signal emission. - * Through evolution this class is slightly misnamed. It is now - * an index into the slot_list passed into it. It simply keeps track - * of where the end of this list was at construction, and pretends that's - * the end of your list. This way you may connect during emission without - * inadvertently entering an infinite loop, as well as make other - * modifications to the slot_list at your own risk. - */ -struct temp_slot_list +/// Exception safe sweeper for cleaning up invalid slots on the slot list. +struct SIGC_API signal_impl_holder { - typedef signal_impl::slot_list slot_list; - typedef signal_impl::iterator_type iterator; - typedef signal_impl::const_iterator_type const_iterator; - - temp_slot_list(slot_list &slots) : slots_(slots) + /** Increments the reference and execution counter of the parent sigc::signal_impl object. + * @param sig The parent sigc::signal_impl object. + */ + inline signal_impl_holder(const std::shared_ptr& sig) noexcept + : sig_(sig), exec_holder_(sig.get()) { - placeholder = slots_.insert(slots_.end(), slot_base()); } - ~temp_slot_list() - { - slots_.erase(placeholder); - } + signal_impl_holder(const signal_impl_holder& src) = delete; + signal_impl_holder operator=(const signal_impl_holder& src) = delete; - iterator begin() { return slots_.begin(); } - iterator end() { return placeholder; } - const_iterator begin() const { return slots_.begin(); } - const_iterator end() const { return placeholder; } + signal_impl_holder(signal_impl_holder&& src) = delete; + signal_impl_holder operator=(signal_impl_holder&& src) = delete; -private: - slot_list &slots_; - slot_list::iterator placeholder; +protected: + /// The parent sigc::signal_impl object. + const std::shared_ptr sig_; + signal_impl_exec_holder exec_holder_; }; - -} /* namespace internal */ +} /* namespace internal */ /** @defgroup signal Signals - * Use sigc::signal::connect() with sigc::mem_fun() and sigc::ptr_fun() to connect a method or function with a signal. + * Use @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()" + * or @ref sigc::signal_with_accumulator::connect_first() "sigc::signal::connect_first()" + * with sigc::mem_fun() and sigc::ptr_fun() to connect a method or function with a signal. * * @code * signal_clicked.connect( sigc::mem_fun(*this, &MyWindow::on_clicked) ); @@ -254,8 +247,9 @@ struct temp_slot_list * If the type of your object inherits from sigc::trackable the method is disconnected * automatically when your object is destroyed. * - * When signals are copied they share the underlying information, - * so you can have a protected/private sigc::signal member and a public accessor method. + * When signals are copied they share the underlying information, so you can have + * a protected/private @ref sigc::signal "sigc::signal" + * member and a public accessor method. * A sigc::signal is a kind of reference-counting pointer. It's similar to * std::shared_ptr<>, although sigc::signal is restricted to holding a pointer to * a sigc::internal::signal_impl object that contains the implementation of the signal. @@ -264,7 +258,7 @@ struct temp_slot_list * class MyClass * { * public: - * typedef sigc::signal MySignalType; + * using MySignalType = sigc::signal; * MySignalType get_my_signal() { return m_my_signal; } * private: * MySignalType m_my_signal; @@ -281,27 +275,53 @@ struct temp_slot_list * if the given functor or closure cannot be invoked with the * parameter list of the signal to connect to. * - * Almost any functor with the correct signature can be converted to a sigc::slot - * and connected to a signal. See @ref slot "Slots" and sigc::signal::connect(). + * Almost any functor with the correct signature can be converted to + * a @ref sigc::slot "sigc::slot" + * and connected to a signal. See @ref slot "Slots" and + * @ref sigc::signal_with_accumulator::connect() "sigc::signal::connect()". + * + * Use @ref sigc::signal_connect() to connect a method or function to a signal + * without having to explicitly write the required template parameters in case + * of method or function overloading. + * + * @code + * sigc::signal sig; + * void fun(int); + * void fun(double); + * sig.connect(sigc::ptr_fun(fun)); + * // or more simply: + * sigc::signal_connect(sig, fun); + * @endcode + * + * It can also be used as a replacement for calling signal::connect() with a + * sigc::mem_fun() or a sigc::ptr_fun(). */ -/** Base class for the sigc::signal# templates. - * signal_base integrates most of the interface of the derived sigc::signal# - * templates. The implementation, however, resides in sigc::internal::signal_impl. - * A sigc::internal::signal_impl object is dynamically allocated from signal_base +// TODO: When we can break ABI, let signal_base derive from trackable again, +// as in sigc++2. Otherwise the slot returned from signal::make_slot() +// is not automatically disconnected when the signal is deleted. +// And delete trackable_signal_with_accumulator and trackable_signal. +// https://github.com/libsigcplusplus/libsigcplusplus/issues/80 + +/** Base class for the @ref sigc::signal "sigc::signal" template. + * %signal_base integrates most of the interface of the derived + * @ref sigc::signal "sigc::signal" template. + * The implementation, however, resides in sigc::internal::signal_impl. + * A sigc::internal::signal_impl object is dynamically allocated from %signal_base * when first connecting a slot to the signal. This ensures that empty signals * don't waste memory. * - * sigc::internal::signal_impl is reference-counted. When a sigc::signal# object + * sigc::internal::signal_impl is reference-counted. + * When a @ref sigc::signal "sigc::signal" object * is copied, the reference count of its sigc::internal::signal_impl object is - * incremented. Both sigc::signal# objects then refer to the same - * sigc::internal::signal_impl object. + * incremented. Both @ref sigc::signal "sigc::signal" objects + * then refer to the same sigc::internal::signal_impl object. * * @ingroup signal */ -struct SIGC_API signal_base : public trackable +struct SIGC_API signal_base { - typedef std::size_t size_type; + using size_type = std::size_t; signal_base() noexcept; @@ -318,8 +338,7 @@ struct SIGC_API signal_base : public trackable /** Returns whether the list of slots is empty. * @return @p true if the list of slots is empty. */ - inline bool empty() const noexcept - { return (!impl_ || impl_->empty()); } + inline bool empty() const noexcept { return (!impl_ || impl_->empty()); } /// Empties the list of slots. void clear(); @@ -356,10 +375,10 @@ struct SIGC_API signal_base : public trackable void unblock() noexcept; protected: - typedef internal::signal_impl::iterator_type iterator_type; + using iterator_type = internal::signal_impl::iterator_type; /** Adds a slot at the end of the list of slots. - * With connect(), slots can also be added during signal emission. + * With %connect(), slots can also be added during signal emission. * In this case, they won't be executed until the next emission occurs. * @param slot_ The slot to add to the list of slots. * @return An iterator pointing to the new slot in the list. @@ -367,7 +386,7 @@ struct SIGC_API signal_base : public trackable iterator_type connect(const slot_base& slot_); /** Adds a slot at the end of the list of slots. - * With connect(), slots can also be added during signal emission. + * With %connect(), slots can also be added during signal emission. * In this case, they won't be executed until the next emission occurs. * @param slot_ The slot to add to the list of slots. * @return An iterator pointing to the new slot in the list. @@ -376,6 +395,26 @@ struct SIGC_API signal_base : public trackable */ iterator_type connect(slot_base&& slot_); + /** Adds a slot at the beginning of the list of slots. + * With %connect_first(), slots can also be added during signal emission. + * In this case, they won't be executed until the next emission occurs. + * @param slot_ The slot to add to the list of slots. + * @return An iterator pointing to the new slot in the list. + * + * @newin{3,6} + */ + iterator_type connect_first(const slot_base& slot_); + + /** Adds a slot at the beginning of the list of slots. + * With %connect_fist(), slots can also be added during signal emission. + * In this case, they won't be executed until the next emission occurs. + * @param slot_ The slot to add to the list of slots. + * @return An iterator pointing to the new slot in the list. + * + * @newin{3,6} + */ + iterator_type connect_first(slot_base&& slot_); + /** Adds a slot at the given position into the list of slots. * Note that this function does not work during signal emission! * @param i An iterator indicating the position where @e slot_ should be inserted. @@ -394,22 +433,15 @@ struct SIGC_API signal_base : public trackable */ iterator_type insert(iterator_type i, slot_base&& slot_); - /** Removes the slot at the given position from the list of slots. - * Note that this function does not work during signal emission! - * @param i An iterator pointing to the slot to be removed. - * @return An iterator pointing to the slot in the list after the one removed. - */ - iterator_type erase(iterator_type i); - /** Returns the signal_impl object encapsulating the list of slots. * @return The signal_impl object encapsulating the list of slots. */ - internal::signal_impl* impl() const; + std::shared_ptr impl() const; /// The signal_impl object encapsulating the slot list. - mutable internal::signal_impl* impl_; + mutable std::shared_ptr impl_; }; -} //namespace sigc +} // namespace sigc -#endif /* _SIGC_SIGNAL_BASE_H_ */ +#endif /* SIGC_SIGNAL_BASE_H */ diff --git a/sigc++/signal_connect.h b/sigc++/signal_connect.h new file mode 100644 index 00000000..c00516f3 --- /dev/null +++ b/sigc++/signal_connect.h @@ -0,0 +1,76 @@ +/* Copyright 2024, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_SIGNAL_CONNECT_H +#define SIGC_SIGNAL_CONNECT_H + +#include +#include +#include + +namespace sigc +{ + +/** Connect a function to a signal + * @param signal The signal to connect to. + * @param fun The function that should be wrapped. + * @return A connection. + * + * @newin{3,8} + * @ingroup signal + */ +template +inline connection +signal_connect(signal& signal, T_return (*fun)(T_arg...)) +{ + return signal.connect(ptr_fun(fun)); +} + +/** Connect a non-const method to a signal + * @param signal The signal to connect to. + * @param obj Reference to object instance the functor should operate on. + * @param fun Pointer to method that should be wrapped. + * @return A connection. + * + * @newin{3,8} + * @ingroup signal + */ +template +inline connection +signal_connect(signal& signal, T_obj& obj, T_return (T_obj::*fun)(T_arg...)) +{ + return signal.connect(mem_fun(obj, fun)); +} + +/** Connect a const method to a signal + * @param signal The signal to connect to. + * @param obj Reference to object instance the functor should operate on. + * @param fun Pointer to method that should be wrapped. + * @return A connection. + * + * @newin{3,8} + * @ingroup signal + */ +template +inline connection +signal_connect(signal& signal, const T_obj& obj, T_return (T_obj::*fun)(T_arg...) const) +{ + return signal.connect(mem_fun(obj, fun)); +} + +} /* namespace sigc */ + +#endif /* SIGC_SIGNAL_CONNECT_H */ diff --git a/sigc++/slot.h b/sigc++/slot.h index 2490f123..b4ef42c8 100644 --- a/sigc++/slot.h +++ b/sigc++/slot.h @@ -1,4 +1,4 @@ -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -13,8 +13,8 @@ * You should have received a copy of the GNU Lesser General Public * License along with this library. If not, see . */ -#ifndef _SIGC_SLOT_H_ -#define _SIGC_SLOT_H_ +#ifndef SIGC_SLOT_H +#define SIGC_SLOT_H #include -#endif /* _SIGC_SLOT_H_ */ +#endif /* SIGC_SLOT_H */ diff --git a/sigc++/trackable.cc b/sigc++/trackable.cc index 135d1caf..e4e3da51 100644 --- a/sigc++/trackable.cc +++ b/sigc++/trackable.cc @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,9 +11,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ #include @@ -22,15 +19,11 @@ namespace sigc { -trackable::trackable() noexcept -: callback_list_(nullptr) -{} +trackable::trackable() noexcept : callback_list_(nullptr) {} /* Don't copy the notification list. The objects watching src don't need to be notified when the new object dies. */ -trackable::trackable(const trackable& /*src*/) noexcept -: callback_list_(nullptr) -{} +trackable::trackable(const trackable& /*src*/) noexcept : callback_list_(nullptr) {} // Don't move the notification list. // The objects watching src don't need to be notified when the new object dies. @@ -38,25 +31,26 @@ trackable::trackable(const trackable& /*src*/) noexcept // // If trackable's move constructor is modified, check if Glib::Object's // move constructor should be modified similarly. -trackable::trackable(trackable&& src) -: callback_list_(nullptr) +trackable::trackable(trackable&& src) noexcept : callback_list_(nullptr) { src.notify_callbacks(); } -trackable& trackable::operator=(const trackable& src) +trackable& +trackable::operator=(const trackable& src) { - if(this != &src) - notify_callbacks(); //Make sure that we have finished with existing stuff before replacing it. - + if (this != &src) + notify_callbacks(); // Make sure that we have finished with existing stuff before replacing it. + return *this; } -trackable& trackable::operator=(trackable&& src) +trackable& +trackable::operator=(trackable&& src) noexcept { - if(this != &src) + if (this != &src) { - notify_callbacks(); //Make sure that we have finished with existing stuff before replacing it. + notify_callbacks(); // Make sure that we have finished with existing stuff before replacing it. src.notify_callbacks(); // src probably becomes useless. } return *this; @@ -67,25 +61,27 @@ trackable::~trackable() notify_callbacks(); } -void trackable::add_destroy_notify_callback(void* data, func_destroy_notify func) const +void +trackable::add_destroy_notify_callback(notifiable* data, func_destroy_notify func) const { callback_list()->add_callback(data, func); } -void trackable::remove_destroy_notify_callback(void* data) const +void +trackable::remove_destroy_notify_callback(notifiable* data) const { callback_list()->remove_callback(data); } -void trackable::notify_callbacks() +void +trackable::notify_callbacks() { - if (callback_list_) - delete callback_list_; //This invokes all of the callbacks. - + delete callback_list_; // This invokes all of the callbacks. callback_list_ = nullptr; } -internal::trackable_callback_list* trackable::callback_list() const +internal::trackable_callback_list* +trackable::callback_list() const { if (!callback_list_) callback_list_ = new internal::trackable_callback_list; @@ -93,7 +89,6 @@ internal::trackable_callback_list* trackable::callback_list() const return callback_list_; } - namespace internal { @@ -102,41 +97,50 @@ trackable_callback_list::~trackable_callback_list() clearing_ = true; for (auto& callback : callbacks_) + { if (callback.func_) callback.func_(callback.data_); + } } -void trackable_callback_list::add_callback(void* data, func_destroy_notify func) +void +trackable_callback_list::add_callback(notifiable* data, func_destroy_notify func) { - if (!clearing_) // TODO: Is it okay to silently ignore attempts to add dependencies when the list is being cleared? - // I'd consider this a serious application bug, since the app is likely to segfault. - // But then, how should we handle it? Throw an exception? Martin. - callbacks_.push_back(trackable_callback(data, func)); + // TODO: Is it okay to silently ignore attempts to add dependencies when the list + // is being cleared? + // I'd consider this a serious application bug, since the app is likely to segfault. + // But then, how should we handle it? Throw an exception? Martin. + if (!clearing_) + callbacks_.emplace_back(trackable_callback(data, func)); } -void trackable_callback_list::clear() +void +trackable_callback_list::clear() { clearing_ = true; for (auto& callback : callbacks_) - if (callback.func_) + { + if (callback.func_) callback.func_(callback.data_); + } callbacks_.clear(); clearing_ = false; } -void trackable_callback_list::remove_callback(void* data) +void +trackable_callback_list::remove_callback(notifiable* data) { - for (callback_list::iterator i = callbacks_.begin(); i != callbacks_.end(); ++i) + for (auto i = callbacks_.begin(); i != callbacks_.end(); ++i) { auto& callback = *i; if (callback.data_ == data && callback.func_ != nullptr) { - //Don't remove a list element while the list is being cleared. - //It could invalidate the iterator in ~trackable_callback_list() or clear(). - //But it may be necessary to invalidate the callback. See bug 589202. + // Don't remove a list element while the list is being cleared. + // It could invalidate the iterator in ~trackable_callback_list() or clear(). + // But it may be necessary to invalidate the callback. See bug 589202. if (clearing_) callback.func_ = nullptr; else diff --git a/sigc++/trackable.h b/sigc++/trackable.h index 6f9b0178..c985f68a 100644 --- a/sigc++/trackable.h +++ b/sigc++/trackable.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,20 +11,22 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_TRACKABLE_HPP_ -#define _SIGC_TRACKABLE_HPP_ +#ifndef SIGC_TRACKABLE_HPP +#define SIGC_TRACKABLE_HPP #include #include -namespace sigc { +namespace sigc +{ + +struct notifiable; -namespace internal { +namespace internal +{ -typedef void* (*func_destroy_notify) (void* data); +using func_destroy_notify = void (*)(notifiable* data); /** Destroy notification callback. * A destroy notification callback consists of a data pointer and a @@ -35,10 +36,11 @@ typedef void* (*func_destroy_notify) (void* data); */ struct SIGC_API trackable_callback { - void* data_; + notifiable* data_; func_destroy_notify func_; - trackable_callback(void* data, func_destroy_notify func) noexcept - : data_(data), func_(func) {} + trackable_callback(notifiable* data, func_destroy_notify func) noexcept : data_(data), func_(func) + { + } }; /** Callback list. @@ -52,21 +54,20 @@ struct SIGC_API trackable_callback_list /** Add a callback function. * @param data Data that will be sent as a parameter to teh callback function. * @param func The callback function. - * + * */ - void add_callback(void* data, func_destroy_notify func); + void add_callback(notifiable* data, func_destroy_notify func); /** Remove the callback which has this data associated with it. * @param data The data that was given as a parameter to add_callback(). */ - void remove_callback(void* data); + void remove_callback(notifiable* data); /** This invokes all of the callback functions. */ void clear(); - trackable_callback_list() - : clearing_(false) {} + trackable_callback_list() : clearing_(false) {} trackable_callback_list(const trackable_callback_list& src) = delete; trackable_callback_list& operator=(const trackable_callback_list& src) = delete; @@ -78,13 +79,17 @@ struct SIGC_API trackable_callback_list ~trackable_callback_list(); private: - typedef std::list callback_list; + using callback_list = std::list; callback_list callbacks_; - bool clearing_; + bool clearing_; }; } /* namespace internal */ +struct SIGC_API notifiable +{ + using func_destroy_notify = internal::func_destroy_notify; +}; /** Base class for objects with auto-disconnection. * trackable must be inherited when objects shall automatically @@ -106,7 +111,7 @@ struct SIGC_API trackable_callback_list * * @ingroup signal */ -struct SIGC_API trackable +struct SIGC_API trackable : public notifiable { // Concerning noexcept specifications: // libsigc++ does not have complete control of what happens when notify_callbacks() @@ -117,31 +122,31 @@ struct SIGC_API trackable trackable(const trackable& src) noexcept; - trackable(trackable&& src); + trackable(trackable&& src) noexcept; trackable& operator=(const trackable& src); - trackable& operator=(trackable&& src); + trackable& operator=(trackable&& src) noexcept; ~trackable(); - /*virtual ~trackable() {} */ /* we would need a virtual dtor for users - who insist on using "trackable*" as - pointer type for their own derived objects */ + /*virtual ~trackable() {} */ /* we would need a virtual dtor for users + who insist on using "trackable*" as + pointer type for their own derived objects */ + + using func_destroy_notify = internal::func_destroy_notify; - typedef internal::func_destroy_notify func_destroy_notify; - /** Add a callback that is executed (notified) when the trackable object is detroyed. * @param data Passed into func upon notification. * @param func Callback executed upon destruction of the object. */ - void add_destroy_notify_callback(void* data, func_destroy_notify func) const; + void add_destroy_notify_callback(notifiable* data, func_destroy_notify func) const; /** Remove a callback previously installed with add_destroy_notify_callback(). * The callback is not executed. * @param data Parameter passed into previous call to add_destroy_notify_callback(). */ - void remove_destroy_notify_callback(void* data) const; + void remove_destroy_notify_callback(notifiable* data) const; /// Execute and remove all previously installed callbacks. void notify_callbacks(); @@ -158,4 +163,4 @@ struct SIGC_API trackable } /* namespace sigc */ -#endif /* _SIGC_TRACKABLE_HPP_ */ +#endif /* SIGC_TRACKABLE_HPP */ diff --git a/sigc++/tuple-utils/tuple_cdr.h b/sigc++/tuple-utils/tuple_cdr.h new file mode 100644 index 00000000..6cc41e58 --- /dev/null +++ b/sigc++/tuple-utils/tuple_cdr.h @@ -0,0 +1,71 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_TUPLE_UTILS_TUPLE_CDR_H +#define SIGC_TUPLE_UTILS_TUPLE_CDR_H + +#include +#include +#include + +namespace sigc::internal +{ + +/** + * Get the type of a tuple without the first item. + */ +template +struct tuple_type_cdr; // primary template is not defined + +// Partial specialization for tuples of at least one element: +template +struct tuple_type_cdr> +{ + using type = std::tuple; +}; + +namespace detail +{ + +template +constexpr decltype(auto) +tuple_cdr_impl(T&& t, std::index_sequence<0, I...>) +{ + using cdr = typename tuple_type_cdr>::type; + return cdr(std::get(std::forward(t))...); +} + +} // detail namespace + +/** + * Get the a tuple without the first item. + * This is analogous to std::tuple_cat(). + */ +template +constexpr decltype(auto) +tuple_cdr(T&& t) +{ + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + + static_assert(size != 0, "tuple size must be non-zero"); + using seq = std::make_index_sequence; + return detail::tuple_cdr_impl(std::forward(t), seq{}); +} + +} // namespace sigc::internal + +#endif // SIGC_TUPLE_UTILS_TUPLE_CDR_H diff --git a/sigc++/tuple-utils/tuple_end.h b/sigc++/tuple-utils/tuple_end.h new file mode 100644 index 00000000..7fa2e132 --- /dev/null +++ b/sigc++/tuple-utils/tuple_end.h @@ -0,0 +1,86 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_TUPLE_UTILS_TUPLE_END_H +#define SIGC_TUPLE_UTILS_TUPLE_END_H + +#include + +namespace sigc::internal +{ + +namespace detail +{ + +template +struct tuple_type_end_impl +{ + using type = typename tuple_type_end_impl>::type, + remove_from_start - 1>::type; +}; + +template +struct tuple_type_end_impl +{ + using type = T; +}; + +} // detail namespace + +/** + * Get the type of a tuple with the last @a len types of the original. + */ +template +struct tuple_type_end : detail::tuple_type_end_impl::value - len> +{ +}; + +/** + * Get the tuple with the last @a len items of the original. + */ +template +constexpr decltype(auto) // typename tuple_type_end::type +tuple_end(T&& t) +{ + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + static_assert(len <= size, "The tuple size must be greater than or equal to the length."); + + if constexpr (len == 0) + { + // Prevent 'unreferenced formal parameter' warning from MSVC by 'using' t + static_cast(t); + // Recursive calls to tuple_cdr() would result in this eventually, + // but this avoids the extra work: + return std::tuple<>(); + } + else if constexpr (size - len == 0) + { + return std::forward(t); + } + else if constexpr (size - len == 1) + { + return tuple_cdr(std::forward(t)); + } + else + { + return tuple_end(tuple_cdr(std::forward(t))); + } +} + +} // namespace sigc::internal; + +#endif // SIGC_TUPLE_UTILS_TUPLE_END_H diff --git a/sigc++/tuple-utils/tuple_for_each.h b/sigc++/tuple-utils/tuple_for_each.h new file mode 100644 index 00000000..97ffd901 --- /dev/null +++ b/sigc++/tuple-utils/tuple_for_each.h @@ -0,0 +1,117 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_TUPLE_UTILS_TUPLE_FOR_EACH_H +#define SIGC_TUPLE_UTILS_TUPLE_FOR_EACH_H + +#include + +namespace sigc +{ + +namespace internal +{ + +namespace detail +{ + +template class T_visitor, std::size_t size_from_index, typename... T_extras> +struct tuple_for_each_impl +{ + template + constexpr static void tuple_for_each(T&& t, T_extras&&... extras) + { + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + static_assert(size > 1, "size must be more than 0."); + + constexpr auto index = size - size_from_index; + static_assert(index >= 0, "unexpected index."); + + using element_type = typename std::tuple_element>::type; + T_visitor::visit(std::get(t), std::forward(extras)...); + + tuple_for_each_impl::tuple_for_each( + std::forward(t), std::forward(extras)...); + } +}; + +template class T_visitor, typename... T_extras> +struct tuple_for_each_impl +{ + template + constexpr static void tuple_for_each(T&& t, T_extras&&... extras) + { + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + static_assert(size > 0, "size must be more than 0."); + + constexpr auto index = size - 1; + static_assert(index >= 0, "unexpected index."); + + using element_type = typename std::tuple_element>::type; + T_visitor::visit( + std::get(std::forward(t)), std::forward(extras)...); + } +}; + +template class T_visitor, typename... T_extras> +struct tuple_for_each_impl +{ + template + constexpr static void tuple_for_each(T&& /* t */, T_extras&&... /* extras */) + { + // Do nothing because the tuple has no elements. + } +}; + +} // detail namespace + +/** + * Call the @e T_Visitor functors visit() method for each element, + * from the first to the last. + * + * @tparam T_visitor should be a template that has a static visit() method. + * @tparam T the tuple type. + * @tparam T_extras the types of any extra arguments to pass to @e T_Visitor's + * visit() method. + * @param t The tuple whose elements should be visited. + * @param extras Any extra arguments to pass to @e T_Visitor's visit() method. + */ +template class T_visitor, typename T, typename... T_extras> +constexpr void +tuple_for_each(T&& t, T_extras&&... extras) +{ + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + + if constexpr (size != 0) + { + detail::tuple_for_each_impl::tuple_for_each( + std::forward(t), std::forward(extras)...); + } + else + { + // Prevent 'unreferenced formal parameter' warning from MSVC by 'using' t + static_cast(t); + } +} + +} // namespace internal + +} // namespace sigc + +#endif // SIGC_TUPLE_UTILS_TUPLE_FOR_EACH_H diff --git a/sigc++/tuple-utils/tuple_start.h b/sigc++/tuple-utils/tuple_start.h new file mode 100644 index 00000000..3df08588 --- /dev/null +++ b/sigc++/tuple-utils/tuple_start.h @@ -0,0 +1,87 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_TUPLE_UTILS_TUPLE_START_H +#define SIGC_TUPLE_UTILS_TUPLE_START_H + +#include +#include + +namespace sigc::internal +{ + +namespace detail +{ + +template +struct tuple_type_start_impl; + +template +struct tuple_type_start_impl> +{ + using type = std::tuple::type...>; +}; + +} // detail namespace + +/** + * Get the type of a tuple with just the first @len items. + */ +template +struct tuple_type_start : detail::tuple_type_start_impl> +{ +}; + +namespace detail +{ + +template +struct tuple_start_impl; + +template +struct tuple_start_impl> +{ + static constexpr decltype(auto) tuple_start(T&& t) + { + constexpr auto size = std::tuple_size>::value; + constexpr auto len = sizeof...(I); + static_assert(len <= size, "The tuple size must be greater than or equal to the length."); + + using start = typename tuple_type_start, len>::type; + return start(std::get(std::forward(t))...); + } +}; + +} // detail namespace + +/** + * Get the tuple with the last @a len items of the original. + */ +template +constexpr decltype(auto) // typename tuple_type_end::type +tuple_start(T&& t) +{ + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + static_assert(len <= size, "The tuple size must be greater than or equal to the length."); + + return detail::tuple_start_impl>::tuple_start( + std::forward(t)); +} + +} // namespace sigc::internal; + +#endif // SIGC_TUPLE_UTILS_TUPLE_START_H diff --git a/sigc++/tuple-utils/tuple_transform_each.h b/sigc++/tuple-utils/tuple_transform_each.h new file mode 100644 index 00000000..a4064fa6 --- /dev/null +++ b/sigc++/tuple-utils/tuple_transform_each.h @@ -0,0 +1,108 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 3.0 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_TUPLE_UTILS_TUPLE_TRANSFORM_EACH_H +#define SIGC_TUPLE_UTILS_TUPLE_TRANSFORM_EACH_H + +#include +#include +#include +#include + +namespace sigc::internal +{ + +namespace detail +{ + +template class T_transformer, std::size_t size_from_index> +struct tuple_transform_each_impl +{ + // TODO: Avoid the need to pass t_original all the way into the recursion? + template + constexpr static decltype(auto) tuple_transform_each(T_current&& t, T_original& t_original) + { + if constexpr (size_from_index == 0) + { + // Prevent 'unreferenced formal parameter' warning from MSVC by 'using' + // t_original + static_cast(t_original); + // Do nothing because the tuple has no elements. + return std::forward(t); + } + else + { // TODO: Should this compile without using else to contain the alternative code? + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + constexpr auto index = size - size_from_index; + static_assert(index >= 0, "unexpected index."); + + using from_element_type = typename std::tuple_element>::type; + using to_element_type = + typename std::invoke_result::transform), + from_element_type&>::type; + // Tuples which are input data to std::tuple_cat() should not be declared const. + // Some versions of libc++ has a bug in std::tuple_cat(): All output elements + // coming from a const tuple become const. + // https://github.com/libsigcplusplus/libsigcplusplus/issues/25 + auto t_element = std::tuple( + T_transformer::transform(std::get(t_original))); + + if constexpr (size_from_index == 1) + { + auto tuple_rest = tuple_start(std::forward(t)); + return std::tuple_cat(tuple_rest, t_element); + } + else + { + auto t_start = tuple_start(std::forward(t)); + + // t_end's elements will be copies of the elements in t, so this method's + // caller won't see the changes made in the subsequent call of + // tuple_transform_each() on those copies. That's why we pass t_original + // through too, so we can modify that directly. + // the const version (tuple_transform_each_const()) doesn't have to worry + // about this, though avoiding copying would be more efficient. + auto t_end = tuple_end(t); + + auto t_with_transformed_element = std::tuple_cat(t_start, t_element, t_end); + return tuple_transform_each_impl::tuple_transform_each( + t_with_transformed_element, t_original); + } + } + } +}; + +} // detail namespace + +/** + * Get a tuple with each element having the transformed value of the element + * in the original tuple. + */ +template class T_transformer, typename T> +constexpr decltype(auto) +tuple_transform_each(T&& t) +{ + // We use std::decay_t<> because tuple_size is not defined for references. + constexpr auto size = std::tuple_size>::value; + + return detail::tuple_transform_each_impl::tuple_transform_each( + std::forward(t), t); +} + +} // namespace sigc::internal + +#endif // SIGC_TUPLE_UTILS_TUPLE_TRANSFORM_EACH_H diff --git a/sigc++/type_traits.h b/sigc++/type_traits.h index 41b2a41f..cf6d1eb1 100644 --- a/sigc++/type_traits.h +++ b/sigc++/type_traits.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,51 +11,56 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA - * + * License along with this library; if not, see . */ -#ifndef _SIGC_TYPE_TRAIT_H_ -#define _SIGC_TYPE_TRAIT_H_ +#ifndef SIGC_TYPE_TRAIT_H +#define SIGC_TYPE_TRAIT_H #include +namespace sigc +{ -namespace sigc { - -template +template struct type_trait { - typedef T_type& pass; - typedef const T_type& take; + using pass = T_type&; + using take = const T_type&; }; -template +template struct type_trait { - typedef T_type*& pass; - typedef const T_type*& take; + using pass = T_type*&; + using take = const T_type*&; }; -template +template struct type_trait { - typedef T_type& pass; - typedef T_type& take; + using pass = T_type&; + using take = T_type&; }; -template +template struct type_trait { - typedef const T_type& pass; - typedef const T_type& take; + using pass = const T_type&; + using take = const T_type&; +}; + +template +struct type_trait +{ + using pass = T_type&&; + using take = T_type&&; }; template<> struct type_trait { - typedef void pass; - typedef void take; + using pass = void; + using take = void; }; template @@ -67,4 +71,4 @@ using type_trait_take_t = typename type_trait::take; } /* namespace sigc */ -#endif /* _SIGC_TYPE_TRAIT_H_ */ +#endif /* SIGC_TYPE_TRAIT_H */ diff --git a/sigc++/visit_each.h b/sigc++/visit_each.h index 82f4236b..69140566 100644 --- a/sigc++/visit_each.h +++ b/sigc++/visit_each.h @@ -1,5 +1,4 @@ -/* - * Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -12,95 +11,55 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * License along with this library; if not, see . */ -#ifndef _SIGC_VISIT_EACH_HPP_ -#define _SIGC_VISIT_EACH_HPP_ +#ifndef SIGC_VISIT_EACH_HPP +#define SIGC_VISIT_EACH_HPP #include #include +#include // std::forward +#include -namespace sigc { - -#ifndef DOXYGEN_SHOULD_SKIP_THIS -namespace internal { - -//This should really be an inner class of limit_derived_target, without the T_limit template type, -//But the SUN CC 5.7 (not earlier versions) compiler finds it ambiguous when we specify a particular specialization of it. -//and does not seem to allow us to tell it explicitly that it's an inner class. -template -struct with_type; - -//Specialization for I_derived = false -template struct -with_type -{ - static void execute_(const T_type&, const T_limit&) {} -}; - -//Specialization for I_derived = true -template -struct with_type -{ - static void execute_(const T_type& _A_type, const T_limit& _A_action) - { _A_action.action_(_A_type); } -}; - - -/// Helper struct for visit_each_type(). -template -struct limit_derived_target +namespace sigc { - typedef limit_derived_target T_self; - - template - void operator()(const T_type& _A_type) const - { - with_type::value || std::is_same::value, T_type, T_self>::execute_(_A_type, *this); - } - - limit_derived_target(const T_action& _A_action) - : action_(_A_action) - {} - - T_action action_; -}; -// Specialization for T_target pointer types, to provide a slightly different execute_() implementation. +struct trackable; -template -struct with_type_pointer; - -//Specialization for I_derived = false -template -struct with_type_pointer +#ifndef DOXYGEN_SHOULD_SKIP_THIS +namespace internal { - static void execute_(const T_type&, const T_limit&) {} -}; -//Specialization for I_derived = true -template -struct with_type_pointer -{ - static void execute_(const T_type& _A_type, const T_limit& _A_action) - { _A_action.action_(&_A_type); } -}; +template +constexpr bool is_base_of_or_same_v = + std::is_base_of, std::decay_t>::value || + std::is_same, std::decay_t>::value; -template -struct limit_derived_target +/// Helper struct for visit_each_trackable(). +template +struct limit_trackable_target { - typedef limit_derived_target T_self; - - template - void operator()(const T_type& _A_type) const + template + void operator()(T_type&& type) const { - with_type_pointer::value || std::is_same::value, T_type, T_self>::execute_(_A_type, *this); + // Only call action_() if T_Type derives from trackable. + if constexpr (is_base_of_or_same_v) + { + std::invoke(action_, type); + } + else + { + // Prevent 'unreferenced formal parameter' warning from MSVC by 'using' type + static_cast(type); + } } - limit_derived_target(const T_action& _A_action) - : action_(_A_action) - {} + explicit limit_trackable_target(const T_action& action) : action_(action) {} + + limit_trackable_target(const limit_trackable_target& src) = delete; + limit_trackable_target& operator=(const limit_trackable_target& src) = delete; + limit_trackable_target(limit_trackable_target&& src) = delete; + limit_trackable_target& operator=(limit_trackable_target&& src) = delete; T_action action_; }; @@ -115,8 +74,9 @@ struct limit_derived_target // (argument-dependent lookup), and therefore there is no risk that a visit_each() overload // in e.g. Boost is selected by mistake. -/** sigc::visitor::do_visit_each() performs a functor on each of the targets of a functor. - * All unknown types just call @a _A_action on them. +/** sigc::visitor::do_visit_each() performs a functor on each of the targets of a + * functor. + * All unknown types just call @a action on them. * Add specializations that specialize the @a T_functor argument for your own * functor types, so that subobjects get visited. This is needed to enable * auto-disconnection support for your functor types. @@ -138,12 +98,12 @@ struct limit_derived_target * template <> * struct visitor * { - * template - * static void do_visit_each(const T_action& _A_action, - * const some_ns::some_functor& _A_target) + * template + * static void do_visit_each(const T_action& action, + * const some_ns::some_functor& target) * { - * sigc::visit_each(_A_action, _A_target.some_data_member); - * sigc::visit_each(_A_action, _A_target.some_other_functor); + * sigc::visit_each(action, target.some_data_member); + * sigc::visit_each(action, target.some_other_functor); * } * }; * } @@ -151,13 +111,13 @@ struct limit_derived_target * * @ingroup sigcfunctors */ -template +template struct visitor { - template - static void do_visit_each(const T_action& _A_action, const T_functor& _A_functor) + template + static void do_visit_each(const T_action& action, const T_functor& functor) { - _A_action(_A_functor); + action(functor); } }; @@ -165,41 +125,35 @@ struct visitor * * @ingroup sigcfunctors */ -template -void visit_each(const T_action& _A_action, const T_functor& _A_functor) -{ sigc::visitor::do_visit_each(_A_action, _A_functor); } +template +void +visit_each(const T_action& action, const T_functor& functor) +{ + sigc::visitor::do_visit_each(action, functor); +} /** This function performs a functor on each of the targets * of a functor limited to a restricted type. * + * It is currently used only to call slot_do_bind and slot_do_unbind + * only on trackable-derived arguments of the functors, like a compile-time version of + * if(dynamic_cast parameters + * in the visitor template specialization. + * TODO: Remove the need for slot_do_bind/slot_do_unbind, limit_trackable_target, + * and visit_each_trackable() by just using a constexpr_if + * (previously known as static_if) if that ends up in C++17. + * * @ingroup sigcfunctors */ -template -void visit_each_type(const T_action& _A_action, const T_functor& _A_functor) +template +void +visit_each_trackable(const T_action& action, const T_functor& functor) { - typedef internal::limit_derived_target type_limited_action; - - type_limited_action limited_action(_A_action); - - //specifying the types of the template specialization prevents disconnection of bound trackable references (such as with sigc::ref()), - //probably because the visit_each<> specializations take various different template types, - //in various sequences, and we are probably specifying only a subset of them with this. - // - //But this is required by the AIX (and maybe IRIX MipsPro and Tru64) compilers. - //I guess that sigc::ref() therefore does not work on those platforms. murrayc - // sigc::visit_each(limited_action, _A_functor); - - //g++ (even slightly old ones) is our primary platform, so we could use the non-crashing version. - //However, the explicit version also fixes a crash in a slightly more common case: http://bugzilla.gnome.org/show_bug.cgi?id=169225 - //Users (and distributors) of libsigc++ on AIX (and maybe IRIX MipsPro and Tru64) do - //need to use the version above instead, to allow compilation. - - //Added 2014-03-20: The preceding comment probably does not apply any more, - //now when the visit_each<>() overloads have been replaced by visitor<> specializations. - //It's probably safe to add explicit template parameters on calls to visit_each(), - //visit_each_type() and visitor::do_visit_each(), if necessary. + internal::limit_trackable_target limited_action(action); - sigc::visit_each(limited_action, _A_functor); + sigc::visit_each(limited_action, functor); } } /* namespace sigc */ diff --git a/sigc++/weak_raw_ptr.h b/sigc++/weak_raw_ptr.h new file mode 100644 index 00000000..1830066a --- /dev/null +++ b/sigc++/weak_raw_ptr.h @@ -0,0 +1,101 @@ +/* Copyright 2016, The libsigc++ Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + +#ifndef SIGC_WEAK_RAW_PTR_HPP +#define SIGC_WEAK_RAW_PTR_HPP +#include //Just for notifiable. + +namespace sigc +{ + +struct notifiable; + +namespace internal +{ + +/** T must derive from sigc::trackable. + */ +template +struct weak_raw_ptr : public sigc::notifiable +{ + inline weak_raw_ptr() : p_(nullptr) {} + + inline weak_raw_ptr(T* p) noexcept : p_(p) + { + if (!p) + return; + + p->add_destroy_notify_callback(this, ¬ify_object_invalidated); + } + + inline weak_raw_ptr(const weak_raw_ptr& src) noexcept : p_(src.p_) + { + if (p_) + p_->add_destroy_notify_callback(this, ¬ify_object_invalidated); + } + + inline weak_raw_ptr& operator=(const weak_raw_ptr& src) noexcept + { + if (p_) + { + p_->remove_destroy_notify_callback(this); + } + + p_ = src.p_; + + if (p_) + p_->add_destroy_notify_callback(this, ¬ify_object_invalidated); + + return *this; + } + + // TODO: + weak_raw_ptr(weak_raw_ptr&& src) = delete; + weak_raw_ptr& operator=(weak_raw_ptr&& src) = delete; + + inline ~weak_raw_ptr() noexcept + { + if (p_) + { + p_->remove_destroy_notify_callback(this); + } + } + + inline explicit operator bool() const noexcept { return p_ != nullptr; } + + inline T* operator->() const noexcept { return p_; } + +private: + /** Callback that is executed when the objet is destroyed. + * @param data The object notified (@p this). + */ + static void notify_object_invalidated(notifiable* data) + { + auto self = static_cast(data); + if (!self) + return; + + self->p_ = nullptr; + } + + T* p_; +}; + +} /* namespace internal */ + +} /* namespace sigc */ + +#endif /* SIGC_WEAK_RAW_PTR_HPP */ diff --git a/sigc++config.h.cmake b/sigc++config.h.cmake new file mode 100644 index 00000000..8483ad35 --- /dev/null +++ b/sigc++config.h.cmake @@ -0,0 +1,63 @@ + +/* Define to omit deprecated API from the library. */ +#cmakedefine SIGCXX_DISABLE_DEPRECATED + +/* Major version number of sigc++. */ +#cmakedefine SIGCXX_MAJOR_VERSION @SIGCXX_MAJOR_VERSION@ + +/* Micro version number of sigc++. */ +#cmakedefine SIGCXX_MICRO_VERSION @SIGCXX_MICRO_VERSION@ + +/* Minor version number of sigc++. */ +#cmakedefine SIGCXX_MINOR_VERSION @SIGCXX_MINOR_VERSION@ + +/* Detect Win32 platform */ +#ifdef _WIN32 +# if defined(_MSC_VER) +# define SIGC_MSC 1 +# define SIGC_WIN32 1 +# ifndef LIBSIGCXX_STATIC +# define SIGC_DLL 1 +# endif +# elif defined(__CYGWIN__) +# define SIGC_CONFIGURE 1 +# elif defined(__MINGW32__) +# define SIGC_WIN32 1 +# define SIGC_CONFIGURE 1 +# else +# error "libsigc++ config: Unknown win32 architecture (send me gcc --dumpspecs or equiv)" +# endif +#else /* !_WIN32 */ +# define SIGC_CONFIGURE 1 +#endif /* !_WIN32 */ + +#ifdef SIGC_MSC +/* + * Visual C++ Warning C4251 says that the classes to any member objects in an + * exported class must also be exported. Some of the libsigc++ + * template classes contain std::list members. MS KB article 168958 says + * that it's not possible to export a std::list instantiation due to some + * wacky class nesting issues, so our only options are to ignore the + * warning or to modify libsigc++ to remove the std::list dependency. + * AFAICT, the std::list members are used internally by the library code + * and don't need to be used from the outside, and ignoring the warning + * seems to have no adverse effects, so that seems like a good enough + * solution for now. + */ +# pragma warning(disable:4251) + +#else /* SIGC_MSC */ + +#endif /* !SIGC_MSC */ + +#ifdef SIGC_DLL +# ifdef SIGC_BUILD +# define SIGC_API __declspec(dllexport) +# elif !defined(SIGC_BUILD) +# define SIGC_API __declspec(dllimport) +# else +# define SIGC_API +# endif +#else /* !SIGC_DLL */ +# define SIGC_API +#endif /* !SIGC_DLL */ diff --git a/sigc++config.h.in b/sigc++config.h.in index 22228556..2031e517 100644 --- a/sigc++config.h.in +++ b/sigc++config.h.in @@ -13,25 +13,27 @@ /* Detect Win32 platform */ #ifdef _WIN32 -# if defined(_MSC_VER) -# define SIGC_MSC 1 -# define SIGC_WIN32 1 -# define SIGC_DLL 1 -# elif defined(__CYGWIN__) -# define SIGC_CONFIGURE 1 -# elif defined(__MINGW32__) -# define SIGC_WIN32 1 -# define SIGC_CONFIGURE 1 -# else -# error "libsigc++ config: Unknown win32 architecture (send me gcc --dumpspecs or equiv)" -# endif +#if defined(_MSC_VER) +#define SIGC_MSC 1 +#define SIGC_WIN32 1 +#ifndef LIBSIGCXX_STATIC +#define SIGC_DLL 1 +#endif +#elif defined(__CYGWIN__) +#define SIGC_CONFIGURE 1 +#elif defined(__MINGW32__) +#define SIGC_WIN32 1 +#define SIGC_CONFIGURE 1 +#else +#error "libsigc++ config: Unknown win32 architecture (send me gcc --dumpspecs or equiv)" +#endif #else /* !_WIN32 */ -# define SIGC_CONFIGURE 1 +#define SIGC_CONFIGURE 1 #endif /* !_WIN32 */ #ifdef SIGC_MSC /* - * MS VC7 Warning 4251 says that the classes to any member objects in an + * Visual C++ Warning C4251 says that the classes to any member objects in an * exported class must also be exported. Some of the libsigc++ * template classes contain std::list members. MS KB article 168958 says * that it's not possible to export a std::list instantiation due to some @@ -42,43 +44,20 @@ * seems to have no adverse effects, so that seems like a good enough * solution for now. */ -# pragma warning(disable:4251) - -# define SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD 1 -# define SIGC_NEW_DELETE_IN_LIBRARY_ONLY 1 /* To keep ABI compatibility */ -# define SIGC_PRAGMA_PUSH_POP_MACRO 1 - -#if (_MSC_VER < 1900) && !defined (noexcept) -#define _ALLOW_KEYWORD_MACROS 1 -#define noexcept _NOEXCEPT -#endif +#pragma warning(disable : 4251) #else /* SIGC_MSC */ -/* does the C++ compiler support the use of a particular specialization when - calling operator() template methods. */ -# undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - -/* Define if the non-standard Sun reverse_iterator must be used. */ -# undef SIGC_HAVE_SUN_REVERSE_ITERATOR - -/* does the C++ compiler support the use of a particular specialization when - calling operator() template methods omitting the template keyword. */ -# undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD - -/* does the C++ preprocessor support pragma push_macro() and pop_macro(). */ -# undef SIGC_PRAGMA_PUSH_POP_MACRO - #endif /* !SIGC_MSC */ #ifdef SIGC_DLL -# if defined(SIGC_BUILD) && defined(_WINDLL) -# define SIGC_API __declspec(dllexport) -# elif !defined(SIGC_BUILD) -# define SIGC_API __declspec(dllimport) -# else -# define SIGC_API -# endif +#ifdef SIGC_BUILD +#define SIGC_API __declspec(dllexport) +#elif !defined(SIGC_BUILD) +#define SIGC_API __declspec(dllimport) +#else +#define SIGC_API +#endif #else /* !SIGC_DLL */ -# define SIGC_API +#define SIGC_API #endif /* !SIGC_DLL */ diff --git a/sigc++config.h.meson b/sigc++config.h.meson new file mode 100644 index 00000000..7fe4e765 --- /dev/null +++ b/sigc++config.h.meson @@ -0,0 +1,68 @@ +/* This file is part of libsigc++. */ +#ifndef SIGCXXCONFIG_H_INCLUDED +#define SIGCXXCONFIG_H_INCLUDED + +/* Define to omit deprecated API from the library. */ +#mesondefine SIGCXX_DISABLE_DEPRECATED + +/* Major version number of sigc++. */ +#mesondefine SIGCXX_MAJOR_VERSION + +/* Minor version number of sigc++. */ +#mesondefine SIGCXX_MINOR_VERSION + +/* Micro version number of sigc++. */ +#mesondefine SIGCXX_MICRO_VERSION + +/* Detect Win32 platform */ +#ifdef _WIN32 +#if defined(_MSC_VER) +#define SIGC_MSC 1 +#define SIGC_WIN32 1 +#ifndef LIBSIGCXX_STATIC +#define SIGC_DLL 1 +#endif +#elif defined(__CYGWIN__) +#define SIGC_CONFIGURE 1 +#elif defined(__MINGW32__) +#define SIGC_WIN32 1 +#define SIGC_CONFIGURE 1 +#else +#error "libsigc++ config: Unknown win32 architecture (send me gcc --dumpspecs or equiv)" +#endif +#else /* !_WIN32 */ +#define SIGC_CONFIGURE 1 +#endif /* !_WIN32 */ + +#ifdef SIGC_MSC +/* + * Visual C++ Warning C4251 says that the classes to any member objects in an + * exported class must also be exported. Some of the libsigc++ + * template classes contain std::list members. MS KB article 168958 says + * that it's not possible to export a std::list instantiation due to some + * wacky class nesting issues, so our only options are to ignore the + * warning or to modify libsigc++ to remove the std::list dependency. + * AFAICT, the std::list members are used internally by the library code + * and don't need to be used from the outside, and ignoring the warning + * seems to have no adverse effects, so that seems like a good enough + * solution for now. + */ +#pragma warning(disable : 4251) + +#else /* SIGC_MSC */ + +#endif /* !SIGC_MSC */ + +#ifdef SIGC_DLL +#ifdef SIGC_BUILD +#define SIGC_API __declspec(dllexport) +#elif !defined(SIGC_BUILD) +#define SIGC_API __declspec(dllimport) +#else +#define SIGC_API +#endif +#else /* !SIGC_DLL */ +#define SIGC_API +#endif /* !SIGC_DLL */ + +#endif /* !SIGCXXCONFIG_H_INCLUDED */ diff --git a/subprojects/mm-common.wrap b/subprojects/mm-common.wrap new file mode 100644 index 00000000..296109fa --- /dev/null +++ b/subprojects/mm-common.wrap @@ -0,0 +1,9 @@ +[wrap-git] +directory=mm-common +url=https://gitlab.gnome.org/GNOME/mm-common.git +revision=master +depth=1 + +[provide] +dependency_names = mm-common-libstdc++ +program_names = mm-common-get diff --git a/tests/.gitignore b/tests/.gitignore index be803fcb..0a788ab4 100644 --- a/tests/.gitignore +++ b/tests/.gitignore @@ -3,10 +3,12 @@ /test_accumulated /test_accum_iter /test_bind +/test_bind_as_slot /test_bind_ref /test_bind_refptr /test_bind_return /test_compose +/test_connection /test_copy_invalid_slot /test_cpp11_lambda /test_custom @@ -18,9 +20,11 @@ /test_hide /test_limit_reference /test_mem_fun +/test_member_method_trait /test_ptr_fun /test_retype /test_retype_return +/test_rvalue_ref /test_signal /test_signal_move /test_size @@ -30,4 +34,13 @@ /test_trackable /test_trackable_move /test_track_obj +/test_tuple_cat +/test_tuple_cdr +/test_tuple_end +/test_tuple_for_each +/test_tuple_start +/test_tuple_transform_each /test_visit_each +/test_visit_each_trackable +/test_weak_raw_ptr +/benchmark diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 00000000..4fcbc59c --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,77 @@ +# Copyright 2016, The libsigc++ Development Team +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License, or (at your option) any later version. +# +# This library 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 +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, see . + +enable_testing () + +set (TEST_SOURCE_FILES + test_accum_iter.cc + test_accumulated.cc + test_bind_as_slot.cc + test_bind.cc + test_bind_ref.cc + test_bind_refptr.cc + test_bind_return.cc + test_compose.cc + test_connection.cc + test_copy_invalid_slot.cc + test_cpp11_lambda.cc + test_custom.cc + test_disconnect.cc + test_disconnect_during_emit.cc + test_exception_catch.cc + test_hide.cc + test_limit_reference.cc + test_member_method_trait.cc + test_mem_fun.cc + test_ptr_fun.cc + test_retype.cc + test_retype_return.cc + test_rvalue_ref.cc + test_scoped_connection.cc + test_signal.cc + test_signal_connect.cc + test_signal_move.cc + test_size.cc + test_slot.cc + test_slot_disconnect.cc + test_slot_move.cc + test_trackable.cc + test_trackable_move.cc + test_track_obj.cc + test_tuple_cdr.cc + test_tuple_end.cc + test_tuple_for_each.cc + test_tuple_start.cc + test_tuple_transform_each.cc + test_visit_each.cc + test_visit_each_trackable.cc + test_weak_raw_ptr.cc) + +function (add_sigcpp_test TEST_SOURCE_FILE) + get_filename_component (test_name ${TEST_SOURCE_FILE} NAME_WE) + add_executable (${test_name} ${TEST_SOURCE_FILE} testutilities.cc) + target_link_libraries (${test_name} sigc-${SIGCXX_API_VERSION}) + add_test (NAME ${test_name} + # Help MSVC to find the library that the tests should link against. + COMMAND ${CMAKE_COMMAND} -E env "PATH=$;$ENV{PATH}" $) + + if (MSVC AND test_name MATCHES "^(test_retype_return|test_signal)$") + target_compile_options(${test_name} PRIVATE "/wd4244") + endif() +endfunction (add_sigcpp_test) + +foreach (test_file ${TEST_SOURCE_FILES}) + add_sigcpp_test (${test_file}) +endforeach() diff --git a/tests/Makefile.am b/tests/Makefile.am index f175f32b..c34f0020 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -17,7 +17,11 @@ AM_CPPFLAGS = -I$(top_builddir) -I$(top_srcdir) AM_CXXFLAGS = $(SIGC_WXXFLAGS) -LDADD = $(top_builddir)/sigc++/libsigc-$(SIGCXX_API_VERSION).la + +sigc_libs = $(top_builddir)/sigc++/libsigc-$(SIGCXX_API_VERSION).la +LDADD = $(sigc_libs) + +dist_noinst_DATA = CMakeLists.txt check_PROGRAMS = \ test_accum_iter \ @@ -28,21 +32,24 @@ check_PROGRAMS = \ test_bind_refptr \ test_bind_return \ test_compose \ + test_connection \ test_copy_invalid_slot \ test_cpp11_lambda \ test_custom \ - test_deduce_result_type \ test_disconnect \ test_disconnect_during_emit \ test_exception_catch \ - test_functor_trait \ test_hide \ test_limit_reference \ + test_member_method_trait \ test_mem_fun \ test_ptr_fun \ test_retype \ test_retype_return \ + test_rvalue_ref \ + test_scoped_connection \ test_signal \ + test_signal_connect \ test_signal_move \ test_size \ test_slot \ @@ -51,7 +58,14 @@ check_PROGRAMS = \ test_trackable \ test_trackable_move \ test_track_obj \ - test_visit_each + test_tuple_cdr \ + test_tuple_end \ + test_tuple_for_each \ + test_tuple_start \ + test_tuple_transform_each \ + test_visit_each \ + test_visit_each_trackable \ + test_weak_raw_ptr TESTS = $(check_PROGRAMS) @@ -65,21 +79,24 @@ test_bind_ref_SOURCES = test_bind_ref.cc $(sigc_test_util) test_bind_refptr_SOURCES = test_bind_refptr.cc $(sigc_test_util) test_bind_return_SOURCES = test_bind_return.cc $(sigc_test_util) test_compose_SOURCES = test_compose.cc $(sigc_test_util) +test_connection_SOURCES = test_connection.cc $(sigc_test_util) test_copy_invalid_slot_SOURCES = test_copy_invalid_slot.cc $(sigc_test_util) test_cpp11_lambda_SOURCES = test_cpp11_lambda.cc $(sigc_test_util) test_custom_SOURCES = test_custom.cc $(sigc_test_util) -test_deduce_result_type_SOURCES = test_deduce_result_type.cc $(sigc_test_util) test_disconnect_SOURCES = test_disconnect.cc $(sigc_test_util) test_disconnect_during_emit_SOURCES = test_disconnect_during_emit.cc $(sigc_test_util) test_exception_catch_SOURCES = test_exception_catch.cc $(sigc_test_util) -test_functor_trait_SOURCES = test_functor_trait.cc $(sigc_test_util) test_hide_SOURCES = test_hide.cc $(sigc_test_util) test_limit_reference_SOURCES = test_limit_reference.cc $(sigc_test_util) +test_member_method_trait_SOURCES = test_member_method_trait.cc $(sigc_test_util) test_mem_fun_SOURCES = test_mem_fun.cc $(sigc_test_util) test_ptr_fun_SOURCES = test_ptr_fun.cc $(sigc_test_util) test_retype_SOURCES = test_retype.cc $(sigc_test_util) test_retype_return_SOURCES = test_retype_return.cc $(sigc_test_util) +test_rvalue_ref_SOURCES = test_rvalue_ref.cc $(sigc_test_util) +test_scoped_connection_SOURCES = test_scoped_connection.cc $(sigc_test_util) test_signal_SOURCES = test_signal.cc $(sigc_test_util) +test_signal_connect_SOURCES = test_signal_connect.cc $(sigc_test_util) test_signal_move_SOURCES = test_signal_move.cc $(sigc_test_util) test_size_SOURCES = test_size.cc $(sigc_test_util) test_slot_SOURCES = test_slot.cc $(sigc_test_util) @@ -88,4 +105,19 @@ test_slot_move_SOURCES = test_slot_move.cc $(sigc_test_util) test_trackable_SOURCES = test_trackable.cc $(sigc_test_util) test_trackable_move_SOURCES = test_trackable_move.cc $(sigc_test_util) test_track_obj_SOURCES = test_track_obj.cc $(sigc_test_util) +test_tuple_cdr_SOURCES = test_tuple_cdr.cc $(sigc_test_util) +test_tuple_end_SOURCES = test_tuple_end.cc $(sigc_test_util) +test_tuple_for_each_SOURCES = test_tuple_for_each.cc $(sigc_test_util) +test_tuple_start_SOURCES = test_tuple_start.cc $(sigc_test_util) +test_tuple_transform_each_SOURCES = test_tuple_transform_each.cc $(sigc_test_util) test_visit_each_SOURCES = test_visit_each.cc $(sigc_test_util) +test_visit_each_trackable_SOURCES = test_visit_each_trackable.cc $(sigc_test_util) +test_weak_raw_ptr_SOURCES = test_weak_raw_ptr.cc $(sigc_test_util) + +if SIGC_BUILD_BENCHMARK +check_PROGRAMS += benchmark +benchmark_SOURCES = benchmark.cc $(sigc_test_util) +benchmark_LDADD = $(sigc_libs) \ + $(BOOST_SYSTEM_LIB) \ + $(BOOST_TIMER_LIB) +endif diff --git a/tests/benchmark.cc b/tests/benchmark.cc new file mode 100644 index 00000000..4f11df77 --- /dev/null +++ b/tests/benchmark.cc @@ -0,0 +1,120 @@ +/* Copyright 2003 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + +#include +#include +#include +#include + +const int COUNT = 10000000; + +struct foo : public sigc::trackable +{ + int bar(int a); + int c; +}; + +int +foo::bar(int a) +{ + int b = c; + c = a; + return b; +} + +void +test_slot_call() +{ + foo foobar1; + + // slot benchmark ... + + sigc::slot slot = sigc::mem_fun(foobar1, &foo::bar); + + std::cout << "elapsed time for calling a slot " << COUNT << " times:" << std::endl; + boost::timer::auto_cpu_timer timer; + + for (int i = 0; i < COUNT; ++i) + slot(i); +} + +void +test_signal_emit() +{ + sigc::signal emitter; + + std::cout << "elapsed time for " << COUNT << " emissions (0 slots):" << std::endl; + boost::timer::auto_cpu_timer timer; + + for (int i = 0; i < COUNT; ++i) + emitter(i); +} + +void +test_connected_signal_emit() +{ + foo foobar1; + sigc::signal emitter; + emitter.connect(mem_fun(foobar1, &foo::bar)); + + std::cout << "elapsed time for " << COUNT << " emissions (1 slot):" << std::endl; + boost::timer::auto_cpu_timer timer; + + for (int i = 0; i < COUNT; ++i) + emitter(i); +} + +void +test_connected_multiple_signal_emit() +{ + foo foobar1, foobar2, foobar3, foobar4, foobar5; + + sigc::signal emitter; + emitter.connect(mem_fun(foobar2, &foo::bar)); + emitter.connect(mem_fun(foobar3, &foo::bar)); + emitter.connect(mem_fun(foobar4, &foo::bar)); + emitter.connect(mem_fun(foobar5, &foo::bar)); + + std::cout << "elapsed time for " << COUNT << " emissions (5 slots):" << std::endl; + boost::timer::auto_cpu_timer timer; + + for (int i = 0; i < COUNT; ++i) + emitter(i); +} + +void +test_connect_disconnect() +{ + foo foobar1; + sigc::signal emitter; + sigc::connection conn; + + std::cout << "elapsed time for " << COUNT << " connections/disconnections:" << std::endl; + boost::timer::auto_cpu_timer timer; + + for (int i = 0; i < COUNT; ++i) + { + conn = emitter.connect(mem_fun(foobar1, &foo::bar)); + conn.disconnect(); + } +} + +int +main() +{ + // slot benchmark ... + test_slot_call(); + + // emission benchmark (zero slots) ... + test_signal_emit(); + + // emission benchmark (one slot) ... + test_connected_signal_emit(); + + // emission benchmark (five slot) ... + test_connected_multiple_signal_emit(); + + // connection / disconnection benchmark ... + test_connect_disconnect(); +} diff --git a/tests/memleakcheck.sh b/tests/memleakcheck.sh new file mode 100755 index 00000000..38fbd586 --- /dev/null +++ b/tests/memleakcheck.sh @@ -0,0 +1,23 @@ +#!/bin/bash + +# Run all libsigc++ tests with valgrind, searching for memory leaks. +# Execute this script in the tests directory. +# valgrind --leak-check=full .libs/lt-test_* + +for testprog in test_accum_iter test_accumulated test_bind test_bind_as_slot \ + test_bind_ref test_bind_refptr test_bind_return test_compose test_connection \ + test_copy_invalid_slot test_cpp11_lambda test_custom test_disconnect \ + test_disconnect_during_emit test_exception_catch test_hide \ + test_limit_reference test_member_method_trait test_mem_fun test_ptr_fun \ + test_retype test_retype_return test_rvalue_ref test_signal test_signal_move \ + test_size test_slot test_slot_disconnect test_slot_move test_trackable \ + test_trackable_move test_track_obj test_tuple_cdr test_tuple_end \ + test_tuple_for_each test_tuple_start test_tuple_transform_each \ + test_visit_each test_visit_each_trackable test_weak_raw_ptr +do + echo ================ + echo === $testprog + echo ================ + valgrind --leak-check=full .libs/lt-$testprog +done + diff --git a/tests/meson.build b/tests/meson.build new file mode 100644 index 00000000..4b627e94 --- /dev/null +++ b/tests/meson.build @@ -0,0 +1,107 @@ +# tests + +# input: sigcxx_own_dep, build_tests, do_benchmark, can_benchmark, benchmark_dep + +benchmark_timeout = 100 + +test_programs = [ +# [[dir-name], exe-name, [sources]] + [[], 'test_accum_iter', ['test_accum_iter.cc', 'testutilities.cc']], + [[], 'test_accumulated', ['test_accumulated.cc', 'testutilities.cc']], + [[], 'test_bind', ['test_bind.cc', 'testutilities.cc']], + [[], 'test_bind_as_slot', ['test_bind_as_slot.cc', 'testutilities.cc']], + [[], 'test_bind_ref', ['test_bind_ref.cc', 'testutilities.cc']], + [[], 'test_bind_refptr', ['test_bind_refptr.cc', 'testutilities.cc']], + [[], 'test_bind_return', ['test_bind_return.cc', 'testutilities.cc']], + [[], 'test_compose', ['test_compose.cc', 'testutilities.cc']], + [[], 'test_connection', ['test_connection.cc', 'testutilities.cc']], + [[], 'test_copy_invalid_slot', ['test_copy_invalid_slot.cc', 'testutilities.cc']], + [[], 'test_cpp11_lambda', ['test_cpp11_lambda.cc', 'testutilities.cc']], + [[], 'test_custom', ['test_custom.cc', 'testutilities.cc']], + [[], 'test_disconnect', ['test_disconnect.cc', 'testutilities.cc']], + [[], 'test_disconnect_during_emit', ['test_disconnect_during_emit.cc', 'testutilities.cc']], + [[], 'test_exception_catch', ['test_exception_catch.cc', 'testutilities.cc']], + [[], 'test_hide', ['test_hide.cc', 'testutilities.cc']], + [[], 'test_limit_reference', ['test_limit_reference.cc', 'testutilities.cc']], + [[], 'test_member_method_trait', ['test_member_method_trait.cc', 'testutilities.cc']], + [[], 'test_mem_fun', ['test_mem_fun.cc', 'testutilities.cc']], + [[], 'test_ptr_fun', ['test_ptr_fun.cc', 'testutilities.cc']], + [[], 'test_retype', ['test_retype.cc', 'testutilities.cc']], + [[], 'test_retype_return', ['test_retype_return.cc', 'testutilities.cc']], + [[], 'test_rvalue_ref', ['test_rvalue_ref.cc', 'testutilities.cc']], + [[], 'test_scoped_connection', ['test_scoped_connection.cc', 'testutilities.cc']], + [[], 'test_signal', ['test_signal.cc', 'testutilities.cc']], + [[], 'test_signal_connect', ['test_signal_connect.cc', 'testutilities.cc']], + [[], 'test_signal_move', ['test_signal_move.cc', 'testutilities.cc']], + [[], 'test_size', ['test_size.cc', 'testutilities.cc']], + [[], 'test_slot', ['test_slot.cc', 'testutilities.cc']], + [[], 'test_slot_disconnect', ['test_slot_disconnect.cc', 'testutilities.cc']], + [[], 'test_slot_move', ['test_slot_move.cc', 'testutilities.cc']], + [[], 'test_trackable', ['test_trackable.cc', 'testutilities.cc']], + [[], 'test_trackable_move', ['test_trackable_move.cc', 'testutilities.cc']], + [[], 'test_track_obj', ['test_track_obj.cc', 'testutilities.cc']], + [[], 'test_tuple_cdr', ['test_tuple_cdr.cc', 'testutilities.cc']], + [[], 'test_tuple_end', ['test_tuple_end.cc', 'testutilities.cc']], + [[], 'test_tuple_for_each', ['test_tuple_for_each.cc', 'testutilities.cc']], + [[], 'test_tuple_start', ['test_tuple_start.cc', 'testutilities.cc']], + [[], 'test_tuple_transform_each', ['test_tuple_transform_each.cc', 'testutilities.cc']], + [[], 'test_visit_each', ['test_visit_each.cc', 'testutilities.cc']], + [[], 'test_visit_each_trackable', ['test_visit_each_trackable.cc', 'testutilities.cc']], + [[], 'test_weak_raw_ptr', ['test_weak_raw_ptr.cc', 'testutilities.cc']], +] + +benchmark_programs = [ +# [[dir-name], exe-name, [sources]] + [[], 'benchmark1', ['benchmark.cc']], +] + +foreach ex : test_programs + dir = '' + foreach dir_part : ex[0] + dir = dir / dir_part + endforeach + ex_name = (dir / ex[1]).underscorify() + ex_sources = [] + foreach src : ex[2] + ex_sources += dir / src + endforeach + + exe_file = executable(ex_name, ex_sources, + dependencies: sigcxx_own_dep, + implicit_include_directories: false, + build_by_default: build_tests, + install: false, + ) + + # If exe_file is a test program, it is built by default unconditionally. + if build_tests + test(ex_name, exe_file) + endif +endforeach + +if can_benchmark + foreach ex : benchmark_programs + dir = '' + foreach dir_part : ex[0] + dir = dir / dir_part + endforeach + ex_name = (dir / ex[1]).underscorify() + ex_sources = [] + foreach src : ex[2] + ex_sources += dir / src + endforeach + + exe_file = executable(ex_name, ex_sources, + dependencies: [sigcxx_own_dep, benchmark_dep], + implicit_include_directories: false, + build_by_default: do_benchmark, + install: false, + ) + + if do_benchmark + test(ex_name, exe_file, + timeout: benchmark_timeout, + ) + endif + endforeach +endif diff --git a/tests/test_accum_iter.cc b/tests/test_accum_iter.cc index 486fa27e..10f70e18 100644 --- a/tests/test_accum_iter.cc +++ b/tests/test_accum_iter.cc @@ -1,15 +1,17 @@ +/* Copyright 2007 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + #include "testutilities.h" #include -#include #include -#include -#include namespace { std::ostringstream result_stream; -int ident(int i) +int +ident(int i) { return i; } @@ -17,14 +19,8 @@ int ident(int i) template struct min_accum { - typedef T result_type; - - template -#ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR - typename std::iterator_traits::value_type operator()(I i1, I i2) -#else - typename I::value_type operator()(I i1, I i2) -#endif + template + decltype(auto) operator()(I i1, I i2) { return *std::min_element(i1, i2); } @@ -32,14 +28,15 @@ struct min_accum } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - sigc::signal0 > signal; + sigc::signal::accumulated> signal; signal.connect(sigc::bind(sigc::ptr_fun(ident), 3)); signal.connect(sigc::bind(sigc::ptr_fun(ident), 1)); diff --git a/tests/test_accumulated.cc b/tests/test_accumulated.cc index adbc2956..7fa81cc9 100644 --- a/tests/test_accumulated.cc +++ b/tests/test_accumulated.cc @@ -1,25 +1,21 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include -#include -#include #include #include -#include namespace { + +TestUtilities* util = nullptr; std::ostringstream result_stream; struct arithmetic_mean_accumulator { - typedef double result_type; template double operator()(T_iterator first, T_iterator last) const { @@ -31,28 +27,29 @@ struct arithmetic_mean_accumulator } }; -template +template struct vector_accumulator { - typedef std::vector result_type; template - result_type operator()(T_iterator first, T_iterator last) const + std::vector operator()(T_iterator first, T_iterator last) const { - result_type vec; + std::vector vec; for (; first != last; ++first) vec.push_back(*first); return vec; } }; -int foo(int i) +int +foo(int i) { const int result = 3 * i + 1; result_stream << "foo: " << result << ", "; return result; } -int bar(double i) +int +bar(double i) { const int result = 5 * int(i) - 3; result_stream << "bar: " << result << ", "; @@ -69,58 +66,81 @@ struct A : public sigc::trackable } }; -} // end anonymous namespace - -int main(int argc, char* argv[]) +void +test_empty_signal() { - auto util = TestUtilities::get_instance(); - - if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - - sigc::signal::accumulated sig; - sigc::signal::accumulated > sig_vec; + sigc::signal::accumulated sig; + sigc::signal::accumulated> sig_vec; result_stream << "Result (empty slot list): " << sig(0); util->check_result(result_stream, "Result (empty slot list): -1"); result_stream << "Vector result (empty slot list): " << (sig_vec(0).empty() ? "empty" : "not empty"); util->check_result(result_stream, "Vector result (empty slot list): empty"); +} - A a; - sig.connect(sigc::ptr_fun1(&foo)); - sig.connect(sigc::mem_fun1(&a, &A::foo)); - sig.connect(sigc::ptr_fun1(&bar)); +template +void +test_mean() +{ + typename T_signal::template accumulated sig; - sig_vec.connect(sigc::ptr_fun1(&foo)); - sig_vec.connect(sigc::mem_fun1(&a, &A::foo)); - sig_vec.connect(sigc::ptr_fun1(&bar)); + A a; + sig.connect(sigc::ptr_fun(&foo)); + sig.connect(sigc::mem_fun(a, &A::foo)); + sig.connect(sigc::ptr_fun(&bar)); double dres = sig(1); - result_stream << "Mean accumulator: Result (i=1): " - << std::fixed << std::setprecision(3) << dres; - util->check_result(result_stream, - "foo: 4, A::foo: 6, bar: 2, Mean accumulator: Result (i=1): 4.000"); + result_stream << "Mean accumulator: Result (i=1): " << std::fixed << std::setprecision(3) << dres; + util->check_result( + result_stream, "foo: 4, A::foo: 6, bar: 2, Mean accumulator: Result (i=1): 4.000"); dres = sig(11); - result_stream << "Mean accumulator: Plain Result (i=11): " - << std::fixed << std::setprecision(3) << dres; - util->check_result(result_stream, - "foo: 34, A::foo: 206, bar: 52, Mean accumulator: Plain Result (i=11): 97.333"); + result_stream << "Mean accumulator: Plain Result (i=11): " << std::fixed << std::setprecision(3) + << dres; + util->check_result( + result_stream, "foo: 34, A::foo: 206, bar: 52, Mean accumulator: Plain Result (i=11): 97.333"); +} + +void +test_vector_accumulator() +{ + sigc::signal::accumulated> sig_vec; + + A a; + sig_vec.connect(sigc::ptr_fun(&foo)); + sig_vec.connect(sigc::mem_fun(a, &A::foo)); + sig_vec.connect(sigc::ptr_fun(&bar)); auto res1 = sig_vec(1); result_stream << "Vector accumulator: Result (i=1): "; for (auto num : res1) result_stream << num << " "; - util->check_result(result_stream, - "foo: 4, A::foo: 6, bar: 2, Vector accumulator: Result (i=1): 4 6 2 "); + util->check_result( + result_stream, "foo: 4, A::foo: 6, bar: 2, Vector accumulator: Result (i=1): 4 6 2 "); auto res3 = sig_vec(3); result_stream << "Vector accumulator: Result (i=3): "; for (auto num : res3) result_stream << num << " "; - util->check_result(result_stream, - "foo: 10, A::foo: 46, bar: 12, Vector accumulator: Result (i=3): 10 46 12 "); + util->check_result( + result_stream, "foo: 10, A::foo: 46, bar: 12, Vector accumulator: Result (i=3): 10 46 12 "); +} + +} // end anonymous namespace + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_empty_signal(); + test_mean>(); + test_mean>(); + test_vector_accumulator(); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_bind.cc b/tests/test_bind.cc index 845d54c0..0cd192ca 100644 --- a/tests/test_bind.cc +++ b/tests/test_bind.cc @@ -1,33 +1,26 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include -#include -#include namespace { std::ostringstream result_stream; -struct foo : public sigc::functor_base +struct foo { - // choose a type that can hold all return values - typedef int result_type; - int operator()(int i) { result_stream << "foo(int " << i << ") "; - return i > 0; + return static_cast(i > 0); } int operator()(int i, int j) { - result_stream << "foo(int " << i << ", int "<< j << ") "; + result_stream << "foo(int " << i << ", int " << j << ") "; return i + j; } @@ -38,49 +31,46 @@ struct foo : public sigc::functor_base } }; -struct foo_void : public sigc::functor_base +struct foo_void { - typedef void result_type; - - void operator()(int i) - { - result_stream << "foo_void(int " << i << ")"; - } + void operator()(int i) { result_stream << "foo_void(int " << i << ")"; } }; -int bar(int i, int j) +int +bar(int i, int j) { result_stream << "bar(int " << i << ", int " << j << ") "; return i + j; } -bool simple(bool test) +bool +simple(bool test) { result_stream << "simple(bool " << test << ") "; return test; } -void egon(std::string& str) +void +egon(std::string& str) { result_stream << "egon(string '" << str << "')"; str = "egon was here"; } - struct book : public sigc::trackable { - book(const std::string& name) : name_(name) {} + explicit book(const std::string& name) : name_(name) {} - //non-copyable: + // non-copyable: book(const book&) = delete; book& operator=(const book&) = delete; - - //non movable: + + // non movable: book(book&&) = delete; book& operator=(book&&) = delete; - std::string& get_name() { return name_; } - operator std::string& () { return get_name(); } + std::string& get_name() { return name_; } + operator std::string&() { return get_name(); } private: std::string name_; @@ -88,7 +78,8 @@ struct book : public sigc::trackable } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -130,7 +121,7 @@ int main(int argc, char* argv[]) // method pointer instead of functor book test_book("otto"); - result_stream << sigc::bind<0>(&book::get_name, sigc::ref(test_book))(); + result_stream << sigc::bind<0>(&book::get_name, std::ref(test_book))(); util->check_result(result_stream, "otto"); // test return type of bind_functor::operator() overload with no arguments @@ -142,25 +133,31 @@ int main(int argc, char* argv[]) // test references std::string str("guest book"); - sigc::bind(&egon, sigc::ref(str))(); // Tell bind that it shall store a reference. - result_stream << " " << str; // (This cannot be the default behaviour: just think about what happens if str dies!) + sigc::bind(&egon, std::ref(str))(); // Tell bind that it shall store a reference. + result_stream + << " " + << str; // (This cannot be the default behaviour: just think about what happens if str dies!) util->check_result(result_stream, "egon(string 'guest book') egon was here"); - sigc::slot sl; + sigc::slot sl; { + // Test without a positional template argument to std::bind(). book guest_book("karl"); - sl = sigc::bind(&egon, sigc::ref(guest_book)); + sl = sigc::bind(&egon, std::ref(guest_book)); sl(); result_stream << " " << static_cast(guest_book); util->check_result(result_stream, "egon(string 'karl') egon was here"); + + // Test with a positional template argument to std::bind<>(). + guest_book.get_name() = "ove"; + sl = sigc::bind<0>(&egon, std::ref(guest_book)); + sl(); + result_stream << " " << static_cast(guest_book); + util->check_result(result_stream, "egon(string 'ove') egon was here"); } // auto-disconnect sl(); util->check_result(result_stream, ""); - // This causes a crash when using g++ 3.3.4 or 3.3.5 (but not 3.4.x) when not specifying - // the exact template specialization in visit_each_type() - see the comments there. - // It looks like the auto-disconnect does not work, so the last sl() call tries - // to access the guest_book data again. return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_bind_as_slot.cc b/tests/test_bind_as_slot.cc index 28bcf4fd..4164fd90 100644 --- a/tests/test_bind_as_slot.cc +++ b/tests/test_bind_as_slot.cc @@ -1,34 +1,32 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include -#include -#include //For std::ref(). -#include namespace { std::ostringstream result_stream; -bool func_to_bind(int a, int b) +bool +func_to_bind(int a, int b) { result_stream << "func_to_bind(" << a << ", " << b << ")"; return true; } -bool func_to_bind_with_iter(int a, std::string::iterator& b) +bool +func_to_bind_with_iter(int a, std::string::iterator& b) { result_stream << "func_to_bind_with_iter(" << a << ", " << *b << ")"; return true; } -bool func_to_bind_with_const_iter(int a, std::string::const_iterator& b) +bool +func_to_bind_with_const_iter(int a, std::string::const_iterator& b) { result_stream << "func_to_bind_with_const_iter(" << a << ", " << *b << ")"; return true; @@ -36,33 +34,35 @@ bool func_to_bind_with_const_iter(int a, std::string::const_iterator& b) } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - - //Test that sigc::bind()'s result can be converted to a sigc::slot<>. + // Test that sigc::bind()'s result can be converted to a sigc::slot<>. { - sigc::slot bound_slot = sigc::bind(sigc::ptr_fun(&func_to_bind), 2); + sigc::slot bound_slot = sigc::bind(sigc::ptr_fun(&func_to_bind), 2); bound_slot(1); util->check_result(result_stream, "func_to_bind(1, 2)"); } - //Test with a non-const iterator: + // Test with a non-const iterator: { std::string c = "2"; - sigc::slot bound_slot = sigc::bind(sigc::ptr_fun(&func_to_bind_with_iter), c.begin()); + sigc::slot bound_slot = + sigc::bind(sigc::ptr_fun(&func_to_bind_with_iter), c.begin()); bound_slot(1); util->check_result(result_stream, "func_to_bind_with_iter(1, 2)"); } - //Test with a const_iterator: + // Test with a const_iterator: { const std::string c = "2"; - sigc::slot bound_slot = sigc::bind(sigc::ptr_fun(&func_to_bind_with_const_iter), c.begin()); + sigc::slot bound_slot = + sigc::bind(sigc::ptr_fun(&func_to_bind_with_const_iter), c.begin()); bound_slot(1); util->check_result(result_stream, "func_to_bind_with_const_iter(1, 2)"); } diff --git a/tests/test_bind_ref.cc b/tests/test_bind_ref.cc index 58bd55da..33c0b9db 100644 --- a/tests/test_bind_ref.cc +++ b/tests/test_bind_ref.cc @@ -1,8 +1,9 @@ +/* Copyright 2005 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + #include "testutilities.h" #include -#include -#include -#include namespace { @@ -11,30 +12,30 @@ std::ostringstream result_stream; class Param : public sigc::trackable { public: - Param(const std::string& name) - : name_(name) - {} + explicit Param(const std::string& name) : name_(name) {} - //non-copyable, - //so it can only be used with sigc::bind() via sigc::ref() + // non-copyable, + // so it can only be used with sigc::bind() via sigc::ref() Param(const Param&) = delete; Param& operator=(const Param&) = delete; - //non movable: + // non movable: Param(Param&&) = delete; Param& operator=(Param&&) = delete; std::string name_; }; -void handler(Param& param) +void +handler(Param& param) { result_stream << " handler(param): param.name_=" << param.name_; } } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -42,32 +43,29 @@ int main(int argc, char* argv[]) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; auto slot_full = sigc::ptr_fun(&handler); - sigc::slot slot_bound; + sigc::slot slot_bound; slot_bound(); util->check_result(result_stream, ""); { - //Because Param derives from sigc::trackable(), sigc::ref() should disconnect + // Because Param derives from sigc::trackable(), std::ref() should disconnect // the signal handler when param is destroyed. Param param("murrayc"); // A convoluted way to do - // slot_bound = sigc::bind(slot_full, sigc::ref(param)); - slot_bound = sigc::bind< -1, sigc::reference_wrapper >(slot_full, sigc::ref(param)); + // slot_bound = sigc::bind(slot_full, std::ref(param)); + slot_bound = sigc::bind<-1, decltype(slot_full), std::reference_wrapper>( + slot_full, std::ref(param)); result_stream << "Calling slot when param exists:"; slot_bound(); - util->check_result(result_stream, - "Calling slot when param exists: handler(param): param.name_=murrayc"); + util->check_result( + result_stream, "Calling slot when param exists: handler(param): param.name_=murrayc"); } // auto-disconnect result_stream << "Calling slot when param does not exist:"; slot_bound(); util->check_result(result_stream, "Calling slot when param does not exist:"); - // This causes a crash when using g++ 3.3.4 or 3.3.5 (but not 3.4.x) when not specifying - // the exact template specialization in visit_each_type() - see the comments there. - // It looks like the auto-disconnect does not work, so the last slot_bound() call tries - // to access the param data again. return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_bind_refptr.cc b/tests/test_bind_refptr.cc index f8fe446a..dd75c4f9 100644 --- a/tests/test_bind_refptr.cc +++ b/tests/test_bind_refptr.cc @@ -1,3 +1,19 @@ +/* Copyright 2002 - 2016, The gtkmm Development Team + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library 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 + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, see . + */ + // Bug 564005 - Valgrind errors and crash on exit with Gtk::UIManager // Bug 154498 - Unnecessary warning on console: signalproxy_connectionnode.cc @@ -7,32 +23,12 @@ #include "testutilities.h" #include -#include -#include #define ACTIVATE_BUG 1 -// -*- c++ -*- #ifndef _GLIBMM_REFPTR_H #define _GLIBMM_REFPTR_H -/* Copyright 2002 The gtkmm Development Team - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free - * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. - */ - //#include namespace Glib @@ -60,7 +56,7 @@ namespace Glib * See the "Memory Management" section in the "Programming with gtkmm" * book for further information. */ -template +template class RefPtr { public: @@ -86,8 +82,8 @@ class RefPtr * * Increments the reference count. */ - template - inline RefPtr(const RefPtr& src); + template + inline explicit RefPtr(const RefPtr& src); /** Swap the contents of two RefPtr<>. * This method swaps the internal pointers to T_CppObject. This can be @@ -103,7 +99,7 @@ class RefPtr * * Increments the reference count. */ - template + template inline RefPtr& operator=(const RefPtr& src); /// Tests whether the RefPtr<> point to the same underlying instance. @@ -130,9 +126,10 @@ class RefPtr inline explicit operator bool() const; #ifndef GLIBMM_DISABLE_DEPRECATED - /// @deprecated Use reset() instead because this leads to confusion with clear() methods on the underlying class. For instance, people use .clear() when they mean ->clear(). + /// @deprecated Use reset() instead because this leads to confusion with clear() methods on the + /// underlying class. For instance, people use .clear() when they mean ->clear(). inline void clear(); -#endif //GLIBMM_DISABLE_DEPRECATED +#endif // GLIBMM_DISABLE_DEPRECATED /** Set underlying instance to 0, decrementing reference count of existing instance appropriately. * @newin{2,16} @@ -146,7 +143,7 @@ class RefPtr * ptr_derived = RefPtr::cast_dynamic(ptr_base); * @endcode */ - template + template static inline RefPtr cast_dynamic(const RefPtr& src); /** Static cast to derived class. @@ -156,7 +153,7 @@ class RefPtr * ptr_derived = RefPtr::cast_static(ptr_base); * @endcode */ - template + template static inline RefPtr cast_static(const RefPtr& src); /** Cast to non-const. @@ -166,7 +163,7 @@ class RefPtr * ptr_unconst = RefPtr::cast_const(ptr_const); * @endcode */ - template + template static inline RefPtr cast_const(const RefPtr& src); /** Compare based on the underlying instance address. @@ -193,73 +190,69 @@ class RefPtr T_CppObject* pCppObject_; }; - #ifndef DOXYGEN_SHOULD_SKIP_THIS // RefPtr<>::operator->() comes first here since it's used by other methods. // If it would come after them it wouldn't be inlined. -template inline -T_CppObject* RefPtr::operator->() const +template +inline T_CppObject* +RefPtr::operator->() const { return pCppObject_; } -template inline -RefPtr::RefPtr() -: - pCppObject_ (nullptr) -{} +template +inline RefPtr::RefPtr() : pCppObject_(nullptr) +{ +} -template inline -RefPtr::~RefPtr() +template +inline RefPtr::~RefPtr() { - if(pCppObject_) + if (pCppObject_) pCppObject_->unreference(); // This could cause pCppObject to be deleted. } -template inline -RefPtr::RefPtr(T_CppObject* pCppObject) -: - pCppObject_ (pCppObject) -{} +template +inline RefPtr::RefPtr(T_CppObject* pCppObject) : pCppObject_(pCppObject) +{ +} -template inline -RefPtr::RefPtr(const RefPtr& src) -: - pCppObject_ (src.pCppObject_) +template +inline RefPtr::RefPtr(const RefPtr& src) : pCppObject_(src.pCppObject_) { - if(pCppObject_) + if (pCppObject_) pCppObject_->reference(); } // The templated ctor allows copy construction from any object that's // castable. Thus, it does downcasts: // base_ref = derived_ref -template - template -inline -RefPtr::RefPtr(const RefPtr& src) -: - // A different RefPtr<> will not allow us access to pCppObject_. We need +template +template +inline RefPtr::RefPtr(const RefPtr& src) +: // A different RefPtr<> will not allow us access to pCppObject_. We need // to add a get_underlying() for this, but that would encourage incorrect // use, so we use the less well-known operator->() accessor: - pCppObject_ (src.operator->()) + pCppObject_(src.operator->()) { - if(pCppObject_) + if (pCppObject_) pCppObject_->reference(); } -template inline -void RefPtr::swap(RefPtr& other) +template +inline void +RefPtr::swap(RefPtr& other) { const auto temp = pCppObject_; pCppObject_ = other.pCppObject_; other.pCppObject_ = temp; } -template inline -RefPtr& RefPtr::operator=(const RefPtr& src) +template +inline RefPtr& +RefPtr::operator=(const RefPtr& src) { // In case you haven't seen the swap() technique to implement copy // assignment before, here's what it does: @@ -285,113 +278,121 @@ RefPtr& RefPtr::operator=(const RefPtr& s // even thinking about it to implement copy assignment whereever the // object data is managed indirectly via a pointer, which is very common. - RefPtr temp (src); + RefPtr temp(src); this->swap(temp); return *this; } -template - template -inline -RefPtr& RefPtr::operator=(const RefPtr& src) +template +template +inline RefPtr& +RefPtr::operator=(const RefPtr& src) { - RefPtr temp (src); + RefPtr temp(src); this->swap(temp); return *this; } -template inline -bool RefPtr::operator==(const RefPtr& src) const +template +inline bool +RefPtr::operator==(const RefPtr& src) const { return (pCppObject_ == src.pCppObject_); } -template inline -bool RefPtr::operator!=(const RefPtr& src) const +template +inline bool +RefPtr::operator!=(const RefPtr& src) const { return (pCppObject_ != src.pCppObject_); } -template inline -RefPtr::operator bool() const +template +inline RefPtr::operator bool() const { return (pCppObject_ != nullptr); } #ifndef GLIBMM_DISABLE_DEPRECATED -template inline -void RefPtr::clear() +template +inline void +RefPtr::clear() { reset(); } -#endif //GLIBMM_DISABLE_DEPRECATED +#endif // GLIBMM_DISABLE_DEPRECATED -template inline -void RefPtr::reset() +template +inline void +RefPtr::reset() { RefPtr temp; // swap with an empty RefPtr<> to clear *this this->swap(temp); } -template - template -inline -RefPtr RefPtr::cast_dynamic(const RefPtr& src) +template +template +inline RefPtr +RefPtr::cast_dynamic(const RefPtr& src) { const auto pCppObject = dynamic_cast(src.operator->()); - if(pCppObject) + if (pCppObject) pCppObject->reference(); return RefPtr(pCppObject); } -template - template -inline -RefPtr RefPtr::cast_static(const RefPtr& src) +template +template +inline RefPtr +RefPtr::cast_static(const RefPtr& src) { const auto pCppObject = static_cast(src.operator->()); - if(pCppObject) + if (pCppObject) pCppObject->reference(); return RefPtr(pCppObject); } -template - template -inline -RefPtr RefPtr::cast_const(const RefPtr& src) +template +template +inline RefPtr +RefPtr::cast_const(const RefPtr& src) { const auto pCppObject = const_cast(src.operator->()); - if(pCppObject) + if (pCppObject) pCppObject->reference(); return RefPtr(pCppObject); } -template inline -bool RefPtr::operator<(const RefPtr& src) const +template +inline bool +RefPtr::operator<(const RefPtr& src) const { return (pCppObject_ < src.pCppObject_); } -template inline -bool RefPtr::operator<=(const RefPtr& src) const +template +inline bool +RefPtr::operator<=(const RefPtr& src) const { return (pCppObject_ <= src.pCppObject_); } -template inline -bool RefPtr::operator>(const RefPtr& src) const +template +inline bool +RefPtr::operator>(const RefPtr& src) const { return (pCppObject_ > src.pCppObject_); } -template inline -bool RefPtr::operator>=(const RefPtr& src) const +template +inline bool +RefPtr::operator>=(const RefPtr& src) const { return (pCppObject_ >= src.pCppObject_); } @@ -399,18 +400,17 @@ bool RefPtr::operator>=(const RefPtr& src) const #endif /* DOXYGEN_SHOULD_SKIP_THIS */ /** @relates Glib::RefPtr */ -template inline -void swap(RefPtr& lhs, RefPtr& rhs) +template +inline void +swap(RefPtr& lhs, RefPtr& rhs) { lhs.swap(rhs); } } // namespace Glib - #endif /* _GLIBMM_REFPTR_H */ - namespace { std::ostringstream result_stream; @@ -418,40 +418,39 @@ std::ostringstream result_stream; class Action : public sigc::trackable { public: - Action() : ref_count(1) { } + Action() : ref_count(1) {} void reference() { ++ref_count; } - void unreference() { if (--ref_count <= 0) delete this; } + void unreference() + { + if (--ref_count <= 0) + delete this; + } void emit_sig1(int n) { sig1.emit(n); } - sigc::signal& signal_sig1() { return sig1; } + sigc::signal& signal_sig1() { return sig1; } private: - sigc::signal sig1; + sigc::signal sig1; int ref_count; - }; class Test : public sigc::trackable { public: - Test() - : action(new Action) + Test() : action(new Action) { result_stream << "new Test; "; -#ifdef ACTIVATE_BUG //See https://bugzilla.gnome.org/show_bug.cgi?id=564005#c14 - action->signal_sig1().connect(sigc::bind(sigc::mem_fun(this, &Test::on_sig1), action)); +#ifdef ACTIVATE_BUG // See https://bugzilla.gnome.org/show_bug.cgi?id=564005#c14 + action->signal_sig1().connect(sigc::bind(sigc::mem_fun(*this, &Test::on_sig1), action)); #else Glib::RefPtr action2(new Action); - action->signal_sig1().connect(sigc::bind(sigc::mem_fun(this, &Test::on_sig1), action2)); + action->signal_sig1().connect(sigc::bind(sigc::mem_fun(*this, &Test::on_sig1), action2)); #endif } - ~Test() - { - result_stream << "delete Test; "; - } + ~Test() { result_stream << "delete Test; "; } void on_sig1(int n, Glib::RefPtr /* action */) { @@ -464,7 +463,8 @@ class Test : public sigc::trackable } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); diff --git a/tests/test_bind_return.cc b/tests/test_bind_return.cc index 88c85ae5..a6dead3c 100644 --- a/tests/test_bind_return.cc +++ b/tests/test_bind_return.cc @@ -1,14 +1,10 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include -#include -#include namespace { @@ -16,28 +12,26 @@ std::ostringstream result_stream; struct foo { - void operator()(int i) - { - result_stream << "foo(int " << i << ") "; - } + void operator()(int i) { result_stream << "foo(int " << i << ") "; } float operator()(float i) { result_stream << "foo(float " << i << ") "; - return i*5; + return i * 5; } }; struct bar : public sigc::trackable { - bar(int i = 0) : i_(i) {} + explicit bar(int i = 0) : i_(i) {} operator int() { return i_; } int i_; }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -52,8 +46,8 @@ int main(int argc, char* argv[]) // references. std::string str("guest book"); // A convoluted way to do - // sigc::bind_return(foo(), sigc::ref(str))(6) = "main"; - sigc::bind_return >(foo(), sigc::ref(str))(6) = "main"; + // sigc::bind_return(foo(), std::ref(str))(6) = "main"; + sigc::bind_return>(foo(), std::ref(str))(6) = "main"; result_stream << str; util->check_result(result_stream, "foo(int 6) main"); @@ -64,10 +58,10 @@ int main(int argc, char* argv[]) // long as there exists a default constructor for it. // // Therefore, we use 'bar', and not 'bar&' for this slot signature. - sigc::slot sl; + sigc::slot sl; { bar choco(-1); - sl = sigc::bind_return(foo(),sigc::ref(choco)); + sl = sigc::bind_return(foo(), std::ref(choco)); result_stream << sl(7); util->check_result(result_stream, "foo(int 7) -1"); } // auto-disconnect diff --git a/tests/test_compose.cc b/tests/test_compose.cc index a626ba62..11b6e3c8 100644 --- a/tests/test_compose.cc +++ b/tests/test_compose.cc @@ -1,15 +1,9 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include - -// assume existance of T_functor::result_type for unknown functor types: -namespace sigc { SIGC_FUNCTORS_HAVE_RESULT_TYPE } namespace { @@ -17,79 +11,49 @@ std::ostringstream result_stream; struct set { - // choose a type that can hold all return values - typedef double result_type; - double operator()(int i) { result_stream << "set(int " << i << ") "; - return i*i; + return i * i; } double operator()(double i) { result_stream << "set(double " << i << ") "; - return i*5; + return i * 5; } }; struct set_void { - typedef void result_type; - - void operator()(double i) - { - result_stream << "set_void(double " << i << ")"; - } + void operator()(double i) { result_stream << "set_void(double " << i << ")"; } }; struct get { -#ifdef SIGC_CXX_TYPEOF - bool operator()() - { - result_stream << "get() "; - return true; - } - - int operator()(int i) - { - result_stream << "get(" << i << ") "; - return i*2; - } - - double operator()(int i, int j) - { - result_stream << "get(" << i << ", " << j << ") "; - return double(i)/double(j); - } -#else - // choose a type that can hold all return values - typedef double result_type; - double operator()() { result_stream << "get() "; - return true; + return static_cast(true); } double operator()(int i) { result_stream << "get(" << i << ") "; - return i*2; + return i * 2; } double operator()(int i, int j) { result_stream << "get(" << i << ", " << j << ") "; - return double(i)/double(j); + return double(i) / double(j); } -#endif }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -105,7 +69,7 @@ int main(int argc, char* argv[]) result_stream << sigc::compose(set(), get())(1, 2); util->check_result(result_stream, "get(1, 2) set(double 0.5) 2.5"); - sigc::compose(set_void(), get())(3); //void test + sigc::compose(set_void(), get())(3); // void test util->check_result(result_stream, "get(3) set_void(double 6)"); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; diff --git a/tests/test_connection.cc b/tests/test_connection.cc new file mode 100644 index 00000000..ec12765b --- /dev/null +++ b/tests/test_connection.cc @@ -0,0 +1,45 @@ +/* Copyright 2019, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + +#include "testutilities.h" +#include +#include +#include + +namespace +{ + +TestUtilities* util = nullptr; +std::ostringstream result_stream; + +void +test_connection_copy_empty() +{ + sigc::connection con1; + + // Try to prevent the compiler from optimising away the copy. + std::cout << &con1 << std::endl; + + sigc::connection con2(con1); + + // Try to prevent the compiler from optimising away the copy. + std::cout << &con2 << std::endl; +} + +} // end anonymous namespace + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_connection_copy_empty(); + + // See also test_disconnection.cc + + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/test_copy_invalid_slot.cc b/tests/test_copy_invalid_slot.cc index b480a154..6b85f604 100644 --- a/tests/test_copy_invalid_slot.cc +++ b/tests/test_copy_invalid_slot.cc @@ -1,22 +1,25 @@ +/* Copyright 2005 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + #include "testutilities.h" -#include -#include #include -#include -#include +#include namespace { std::ostringstream result_stream; -void Foo(sigc::trackable&) +void +Foo(sigc::trackable&) { result_stream << "Foo(x)"; } } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -30,7 +33,7 @@ int main(int argc, char* argv[]) util->check_result(result_stream, "sigc::trackable instance at " + pointer_stream.str()); pointer_stream.str(""); - sigc::slot foo = sigc::bind(sigc::ptr_fun(Foo), sigc::ref(*t)); + sigc::slot foo = sigc::bind(sigc::ptr_fun(Foo), std::ref(*t)); foo(); util->check_result(result_stream, "Foo(x)"); @@ -55,7 +58,7 @@ int main(int argc, char* argv[]) // Now copy foo: up to libsigc++ version 2.0.11, the copy constructor fails // because the pointer value it dereferences does not point to a // sigc::trackable anymore, it now points to a polluted buffer. - sigc::slot bar = foo; + sigc::slot bar = foo; bar(); util->check_result(result_stream, ""); diff --git a/tests/test_cpp11_lambda.cc b/tests/test_cpp11_lambda.cc index e97b80e8..40534e25 100644 --- a/tests/test_cpp11_lambda.cc +++ b/tests/test_cpp11_lambda.cc @@ -1,4 +1,4 @@ -/* Copyright (C) 2012 The libsigc++ Development Team +/* Copyright (C) 2012 - 2016, The libsigc++ Development Team * * This file is part of libsigc++. * @@ -32,7 +32,7 @@ // The only real disadvantage of the C++11 lambda expressions is that a slot that // contains an object derived from sigc::trackable is not automatically disconnected // when the object is deleted, if a reference to the object is stored in a C++11 -// lambda expression, connected to the slot. But if you use sigc::track_obj(), +// lambda expression, connected to the slot. But if you use sigc::track_object(), // the slot is automatically disconnected. Thus, the disadvantage is insignificant. // // To test the C++11 lambda expressions with gcc 4.6.3 (and probably some later @@ -42,31 +42,27 @@ // echo $? // If test_cpp11_lambda writes nothing and the return code is 0, the test has passed. - #include "testutilities.h" -#include #include -#include #include -#include #include #include -#include #include #include - namespace { std::ostringstream result_stream; -int foo(int i, int j) +int +foo(int i, int j) { result_stream << "foo(int " << i << ", int " << j << ") "; - return 4*i + j; + return 4 * i + j; } -void foo_void(int i) +void +foo_void(int i) { result_stream << "foo_void(int " << i << ")"; } @@ -76,16 +72,14 @@ struct bar int test(int i, int j) { result_stream << "bar::test(int " << i << ", int " << j << ") "; - return 4*i + j; + return 4 * i + j; } - void test_void(int i) - { - result_stream << "bar::test_void(int " << i << ")"; - } + void test_void(int i) { result_stream << "bar::test_void(int " << i << ")"; } }; -void egon(std::string& str) +void +egon(std::string& str) { result_stream << "egon(string '" << str << "')"; str = "egon was here"; @@ -94,33 +88,38 @@ void egon(std::string& str) struct book : public sigc::trackable { explicit book(const std::string& name) : name_(name) {} - operator std::string& () { return name_; } + operator std::string&() { return name_; } std::string name_; }; -inline std::ostringstream& operator << (std::ostringstream& s, const book& b) +inline std::ostringstream& +operator<<(std::ostringstream& s, const book& b) { s << b.name_; return s; } -void foo_group1(int i, int j) +void +foo_group1(int i, int j) { result_stream << "foo_group1(int " << i << ", int " << j << ")"; } -int bar_group1(int i) +int +bar_group1(int i) { result_stream << "bar_group1(int " << i << ") "; return i + 2; } -void foo_group2(int i) +void +foo_group2(int i) { result_stream << "foo_group2(int " << i << ")"; } -void foo_group3(int& i) +void +foo_group3(int& i) { result_stream << "foo_group3(int " << i << ")"; ++i; @@ -130,148 +129,156 @@ struct bar_group4 : public sigc::trackable { }; -void foo_group4(bar_group4&) +void +foo_group4(bar_group4&) { result_stream << "foo_group4(bar_group4&)"; } } // end anonymous namespace - - -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - // test lambda operators - //std::cout << "(_1 + _2) (3,4): " << (_1 + _2) (3,4) << std::endl; - result_stream << ([] (int a, int b) -> int { return a + b; }(3,4)); + // std::cout << "(_1 + _2) (3,4): " << (_1 + _2) (3,4) << std::endl; + result_stream << ([](int a, int b) -> int { return a + b; }(3, 4)); util->check_result(result_stream, "7"); - //std::cout << "(_1 + 1) (3,4): " << (_1 + 1) (3,4) << std::endl; - result_stream << ([] (int a, int) -> int { return a + 1; }(3,4)); + // std::cout << "(_1 + 1) (3,4): " << (_1 + 1) (3,4) << std::endl; + result_stream << ([](int a, int) -> int { return a + 1; }(3, 4)); util->check_result(result_stream, "4"); - //std::cout << "(_2 + 1) (3,4): " << (_2 + 1) (3,4) << std::endl; - result_stream << ([] (int, int b) -> int { return b + 1; }(3,4)); + // std::cout << "(_2 + 1) (3,4): " << (_2 + 1) (3,4) << std::endl; + result_stream << ([](int, int b) -> int { return b + 1; }(3, 4)); util->check_result(result_stream, "5"); - //std::cout << "(2 + _1) (3,4): " << (2 + _1) (3,4) << std::endl; - result_stream << ([] (int a, int) -> int { return 2 + a; }(3,4)); + // std::cout << "(2 + _1) (3,4): " << (2 + _1) (3,4) << std::endl; + result_stream << ([](int a, int) -> int { return 2 + a; }(3, 4)); util->check_result(result_stream, "5"); - //std::cout << "(2 + _2) (3,4): " << (2 + _2) (3,4) << std::endl; - result_stream << ([] (int, int b) -> int { return 2 + b; }(3,4)); + // std::cout << "(2 + _2) (3,4): " << (2 + _2) (3,4) << std::endl; + result_stream << ([](int, int b) -> int { return 2 + b; }(3, 4)); util->check_result(result_stream, "6"); - //std::cout << "(_1+_2*_3)(1,2,3): " << (_1+_2*_3)(1,2,3) << std::endl; - result_stream << ([] (int a, int b, int c) -> int { return a + b*c; }(1,2,3)); + // std::cout << "(_1+_2*_3)(1,2,3): " << (_1+_2*_3)(1,2,3) << std::endl; + result_stream << ([](int a, int b, int c) -> int { return a + b * c; }(1, 2, 3)); util->check_result(result_stream, "7"); - //std::cout << "((++_1)*2)(1): " << ((++_1)*2)(1) << std::endl; - result_stream << ([] (int a) -> int { return ++a * 2; }(1)); + // std::cout << "((++_1)*2)(1): " << ((++_1)*2)(1) << std::endl; + result_stream << ([](int a) -> int { return ++a * 2; }(1)); util->check_result(result_stream, "4"); - //std::cout << "((++_1)*2)(a): " << ((++_1)*2)(a); - //std::cout << "; a: " << a << std::endl; + // std::cout << "((++_1)*2)(a): " << ((++_1)*2)(a); + // std::cout << "; a: " << a << std::endl; int a_outer = 1; - result_stream << ([] (int x) -> int { return ++x * 2; }(a_outer)) << " " << a_outer; + result_stream << ([](int x) -> int { return ++x * 2; }(a_outer)) << " " << a_outer; util->check_result(result_stream, "4 1"); - // gcc can't compile libsigc++ lambda expressions with sigc::ref() parameters. + // gcc can't compile libsigc++ lambda expressions with std::ref() parameters. // See https://bugzilla.gnome.org/show_bug.cgi?id=669128 - // std::cout << "((++_1)*2)(ref(a)): " << ((++_1)*2)(sigc::ref(a)); + // std::cout << "((++_1)*2)(ref(a)): " << ((++_1)*2)(std::ref(a)); // std::cout << "; a: " << a << std::endl; - result_stream << ([] (std::reference_wrapper x) -> int { return ++x * 2; }(std::ref(a_outer))); + result_stream << ([](std::reference_wrapper x) -> int + { return ++x * 2; }(std::ref(a_outer))); result_stream << " " << a_outer; util->check_result(result_stream, "4 2"); - result_stream << ([] (int& x) -> int { return ++x * 2; }(a_outer)); + result_stream << ([](int& x) -> int { return ++x * 2; }(a_outer)); result_stream << " " << a_outer; util->check_result(result_stream, "6 3"); - //std::cout << "((++(*_1))*2)(&a): " << ((++(*_1))*2)(&a); - //std::cout << "; a: " << a << std::endl; - result_stream << ([] (int* x) -> int { return ++(*x) * 2; }(&a_outer)); + // std::cout << "((++(*_1))*2)(&a): " << ((++(*_1))*2)(&a); + // std::cout << "; a: " << a << std::endl; + result_stream << ([](int* x) -> int { return ++(*x) * 2; }(&a_outer)); result_stream << " " << a_outer; util->check_result(result_stream, "8 4"); - // std::cout << "((--(*(&_1)))*2)(ref(a)): " << ((--(*(&_1)))*2)(sigc::ref(a)); + // std::cout << "((--(*(&_1)))*2)(ref(a)): " << ((--(*(&_1)))*2)(std::ref(a)); // std::cout << "; a: " << a << std::endl; - result_stream << ([] (std::reference_wrapper x) -> int { return --(*(&x)) * 2; }(std::ref(a_outer))); + result_stream << ([](std::reference_wrapper x) -> int + { return --(*(&x)) * 2; }(std::ref(a_outer))); result_stream << " " << a_outer; util->check_result(result_stream, "6 3"); - result_stream << ([] (int& x) -> int { return --(*(&x)) * 2; }(a_outer)); + result_stream << ([](int& x) -> int { return --(*(&x)) * 2; }(a_outer)); result_stream << " " << a_outer; util->check_result(result_stream, "4 2"); - //std::cout << "(-_1) (-5): " << (-_1) (-5) << std::endl; - result_stream << ([] (int x) -> int { return -x; }(-5)); + // std::cout << "(-_1) (-5): " << (-_1) (-5) << std::endl; + result_stream << ([](int x) -> int { return -x; }(-5)); util->check_result(result_stream, "5"); - //std::cout << "(var(&a)[0])(): " << (sigc::var(&a)[0])() << std::endl; + // std::cout << "(var(&a)[0])(): " << (sigc::var(&a)[0])() << std::endl; result_stream << ([&a_outer]() -> int { return a_outer; }()); util->check_result(result_stream, "2"); - //std::cout << "(_1[_2]) (&a,0): " << (_1[_2]) (&a,0) << std::endl; - result_stream << ([] (int* x, int y) -> int { return x[y]; }(&a_outer,0)); + // std::cout << "(_1[_2]) (&a,0): " << (_1[_2]) (&a,0) << std::endl; + result_stream << ([](int* x, int y) -> int { return x[y]; }(&a_outer, 0)); util->check_result(result_stream, "2"); - //std::cout << "(*_1=_2) (&a,1): " << (*_1=_2) (&a,1) << std::endl; - result_stream << ([] (int* x, int y) -> int { *x = y; return *x; }(&a_outer,1)); + // std::cout << "(*_1=_2) (&a,1): " << (*_1=_2) (&a,1) << std::endl; + result_stream << ([](int* x, int y) -> int { + *x = y; + return *x; + }(&a_outer, 1)); util->check_result(result_stream, "1"); // Comma operator, https://bugzilla.gnome.org/show_bug.cgi?id=342911 a_outer = -1; int b_outer = -1; int c_outer = -1; - //std::cout << "(var(c) = (var(a) = _1, var(b) = _2))(2,3): " + // std::cout << "(var(c) = (var(a) = _1, var(b) = _2))(2,3): " // << (sigc::var(c) = (sigc::var(a) = _1, sigc::var(b) = _2))(2,3); - //std::cout << "; a: " << a << "; b: " << b << "; c: " << c << std::endl; - result_stream << ([&a_outer,&b_outer,&c_outer](int x, int y) -> int { return c_outer = (a_outer = x, b_outer = y); }(2,3)); + // std::cout << "; a: " << a << "; b: " << b << "; c: " << c << std::endl; + result_stream << ([&a_outer, &b_outer, &c_outer](int x, int y) -> int + { return c_outer = (a_outer = x, b_outer = y); }(2, 3)); result_stream << " " << a_outer << " " << b_outer << " " << c_outer; util->check_result(result_stream, "3 2 3 3"); // c++ restrictions: // - ref() must be used to indicate that the value shall not be copied // - constant() is used to create a lambda and delay execution of "std::cout << 1" - // - var() is used to create a lambda that holds a reference and is interchangable with ref() in lambda operator expressions + // - var() is used to create a lambda that holds a reference and is interchangable with ref() in + // lambda operator expressions // - cannot use std::endl without much hackery because it is defined as a template function // - cannot use "\n" without var() because arrays cannot be copied - // (sigc::ref(std::cout) << sigc::constant(1) << sigc::var("\n"))(); - [](){ result_stream << 1 << "\n"; }(); + // (std::ref(std::cout) << sigc::constant(1) << sigc::var("\n"))(); + []() { result_stream << 1 << "\n"; }(); util->check_result(result_stream, "1\n"); - //(sigc::ref(std::cout) << _1 << std::string("\n"))("hello world"); - [](const char* a){ result_stream << a << std::string("\n"); }("hello world"); + //(std::ref(std::cout) << _1 << std::string("\n"))("hello world"); + [](const char* a) { result_stream << a << std::string("\n"); }("hello world"); util->check_result(result_stream, "hello world\n"); - //(sigc::ref(std::cout) << sigc::static_cast_(_1) << std::string("\n"))(1.234); - [](double a){ result_stream << static_cast(a) << std::string("\n"); }(1.234); + //(std::ref(std::cout) << sigc::static_cast_(_1) << std::string("\n"))(1.234); + [](double a) { result_stream << static_cast(a) << std::string("\n"); }(1.234); util->check_result(result_stream, "1\n"); // (sigc::var(std::cout) << 1 << sigc::var("\n"))(); - [](){ result_stream << 1 << "\n"; }(); + []() { result_stream << 1 << "\n"; }(); util->check_result(result_stream, "1\n"); //(sigc::var(std::cout) << _1 << std::string("\n"))("hello world"); - [](const char* a){ result_stream << a << std::string("\n"); }("hello world"); + [](const char* a) { result_stream << a << std::string("\n"); }("hello world"); util->check_result(result_stream, "hello world\n"); // auto-disconnect // Here's an area where the libsigc++ lambda expressions are advantageous. // If you want to auto-disconnect a slot with a C++11 lambda expression // that contains references to sigc::trackable-derived objects, you must use - // sigc::track_obj(). - sigc::slot sl1; + // sigc::track_object(). + sigc::slot sl1; { book guest_book("karl"); - //sl1 = (sigc::var(std::cout) << sigc::ref(guest_book) << sigc::var("\n")); - // sl1 = [&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }; // no auto-disconnect - sl1 = sigc::track_obj([&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }, guest_book); + // sl1 = (sigc::var(std::cout) << std::ref(guest_book) << sigc::var("\n")); + // sl1 = [&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }; // no + // auto-disconnect + sl1 = sigc::track_object( + [&guest_book](std::ostringstream& stream) { stream << guest_book << "\n"; }, guest_book); sl1(result_stream); util->check_result(result_stream, "karl\n"); @@ -282,27 +289,29 @@ int main(int argc, char* argv[]) // test group adaptor, here replaced by std::bind bar the_bar; - //std::cout << (sigc::group(&foo, _1, _2)) (1, 2) << std::endl; + // std::cout << (sigc::group(&foo, _1, _2)) (1, 2) << std::endl; result_stream << std::bind(&foo, std::placeholders::_1, std::placeholders::_2)(1, 2); util->check_result(result_stream, "foo(int 1, int 2) 6"); - //std::cout << (sigc::group(&foo, _2, _1)) (1, 2) << std::endl; + // std::cout << (sigc::group(&foo, _2, _1)) (1, 2) << std::endl; result_stream << std::bind(&foo, std::placeholders::_2, std::placeholders::_1)(1, 2); util->check_result(result_stream, "foo(int 2, int 1) 9"); - //std::cout << (sigc::group(sigc::mem_fun(&bar::test), _1, _2, _3)) (sigc::ref(the_bar), 1, 2) << std::endl; + // std::cout << (sigc::group(sigc::mem_fun(&bar::test), _1, _2, _3)) (std::ref(the_bar), 1, 2) << + // std::endl; // std::ref(the_bar) is not necessary. It can make the call ambiguous. // Even without std::ref() the_bar is not copied. - result_stream << std::bind(std::mem_fn(&bar::test), std::placeholders::_1, - std::placeholders::_2, std::placeholders::_3)(the_bar, 1, 2); + result_stream << std::bind( + std::mem_fn(&bar::test), std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)( + the_bar, 1, 2); util->check_result(result_stream, "bar::test(int 1, int 2) 6"); // same functionality as bind - //std::cout << (sigc::group(&foo, _1, 2)) (1) << std::endl; + // std::cout << (sigc::group(&foo, _1, 2)) (1) << std::endl; result_stream << std::bind(&foo, std::placeholders::_1, 2)(1); util->check_result(result_stream, "foo(int 1, int 2) 6"); - //std::cout << (sigc::group(&foo, 1, 2)) () << std::endl; + // std::cout << (sigc::group(&foo, 1, 2)) () << std::endl; result_stream << std::bind(&foo, 1, 2)(); util->check_result(result_stream, "foo(int 1, int 2) 6"); @@ -317,17 +326,17 @@ int main(int argc, char* argv[]) // functor has an unambiguous operator()(). // auto-disconnect - sigc::slot sl2; + sigc::slot sl2; { book guest_book("karl"); - //sl2 = sigc::group(&egon, sigc::ref(guest_book)); + // sl2 = sigc::group(&egon, std::ref(guest_book)); // sl2 = [&guest_book] () { egon(guest_book); }; // no auto-disconnect // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) - sl2 = sigc::track_obj([&guest_book] () { egon(guest_book); }, guest_book); + sl2 = sigc::track_object([&guest_book]() { egon(guest_book); }, guest_book); sl2(); util->check_result(result_stream, "egon(string 'karl')"); - //std::cout << static_cast(guest_book) << std::endl; + // std::cout << static_cast(guest_book) << std::endl; result_stream << static_cast(guest_book); util->check_result(result_stream, "egon was here"); @@ -339,15 +348,15 @@ int main(int argc, char* argv[]) // More auto-disconnect { book guest_book("charlie"); - //sl2 = sigc::group(&egon, sigc::ref(guest_book)); + // sl2 = sigc::group(&egon, std::ref(guest_book)); // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) auto fn2 = std::bind(&egon, std::ref(guest_book)); - //sl2 = fn2; // no auto-disconnect - sl2 = sigc::track_obj(fn2, guest_book); + // sl2 = fn2; // no auto-disconnect + sl2 = sigc::track_object(fn2, guest_book); sl2(); util->check_result(result_stream, "egon(string 'charlie')"); - //std::cout << static_cast(guest_book) << std::endl; + // std::cout << static_cast(guest_book) << std::endl; result_stream << static_cast(guest_book); util->check_result(result_stream, "egon was here"); @@ -357,8 +366,8 @@ int main(int argc, char* argv[]) util->check_result(result_stream, ""); // same functionality as hide - //std::cout << (sigc::group(&foo, _1, _2)) (1,2,3) << std::endl; - result_stream << std::bind(&foo, std::placeholders::_1, std::placeholders::_2)(1,2,3); + // std::cout << (sigc::group(&foo, _1, _2)) (1,2,3) << std::endl; + result_stream << std::bind(&foo, std::placeholders::_1, std::placeholders::_2)(1, 2, 3); util->check_result(result_stream, "foo(int 1, int 2) 6"); //(sigc::group(sigc::ptr_fun(&foo_void), _2)) (1, 2); @@ -366,14 +375,15 @@ int main(int argc, char* argv[]) util->check_result(result_stream, "foo_void(int 2)"); // same functionality as compose - //std::cout << (sigc::group(&foo, sigc::group(&foo, _1, _2), _3)) (1,2,3) << std::endl; - result_stream << std::bind(&foo, std::bind(&foo, std::placeholders::_1, std::placeholders::_2), - std::placeholders::_3)(1,2,3); + // std::cout << (sigc::group(&foo, sigc::group(&foo, _1, _2), _3)) (1,2,3) << std::endl; + result_stream << std::bind(&foo, + std::bind(&foo, std::placeholders::_1, std::placeholders::_2), + std::placeholders::_3)(1, 2, 3); util->check_result(result_stream, "foo(int 1, int 2) foo(int 6, int 3) 27"); // same functionality as retype - //std::cout << (sigc::group(&foo, sigc::static_cast_(_1), 2)) (1.234) << std::endl; - result_stream << ([] (double x) -> int { return foo(static_cast(x), 2); }(1.234)); + // std::cout << (sigc::group(&foo, sigc::static_cast_(_1), 2)) (1.234) << std::endl; + result_stream << ([](double x) -> int { return foo(static_cast(x), 2); }(1.234)); util->check_result(result_stream, "foo(int 1, int 2) 6"); // Code examples with C++11 lambda expressions and std::bind, which can replace @@ -382,26 +392,26 @@ int main(int argc, char* argv[]) //--- sigc++/adaptors/lambda/macros/base.h.m4 - //std::cout << sigc::_1(10,20,30); // returns 10 - result_stream << ([] (int x, int, int) -> int { return x; }(10,20,30)); + // std::cout << sigc::_1(10,20,30); // returns 10 + result_stream << ([](int x, int, int) -> int { return x; }(10, 20, 30)); util->check_result(result_stream, "10"); - //std::cout << sigc::_2(10,20,30); // returns 20 - result_stream << ([] (int, int y, int) -> int { return y; }(10,20,30)); + // std::cout << sigc::_2(10,20,30); // returns 20 + result_stream << ([](int, int y, int) -> int { return y; }(10, 20, 30)); util->check_result(result_stream, "20"); - //std::cout << (sigc::_1 + 5)(3); // returns (3 + 5) - result_stream << ([] (int x) -> int { return x + 5; }(3)); + // std::cout << (sigc::_1 + 5)(3); // returns (3 + 5) + result_stream << ([](int x) -> int { return x + 5; }(3)); util->check_result(result_stream, "8"); - //std::cout << (sigc::_1 * sigc::_2)(7,10); // returns (7 * 10) - result_stream << ([] (int x, int y) -> int { return x * y; }(7,10)); + // std::cout << (sigc::_1 * sigc::_2)(7,10); // returns (7 * 10) + result_stream << ([](int x, int y) -> int { return x * y; }(7, 10)); util->check_result(result_stream, "70"); - //int main(int argc, char* argv[]) + // int main(int argc, char* argv[]) //{ // int data; - // sigc::signal readValue; + // sigc::signal readValue; // // readValue.connect(sigc::var(data)); // @@ -413,9 +423,9 @@ int main(int argc, char* argv[]) //} { int data; - sigc::signal readValue; + sigc::signal readValue; - readValue.connect([&data] () -> int { return data; }); + readValue.connect([&data]() -> int { return data; }); data = 3; result_stream << readValue(); @@ -429,65 +439,70 @@ int main(int argc, char* argv[]) //--- sigc++/adaptors/lambda/macros/group.h.m4 // argument binding ... - //sigc::group(&foo,10,sigc::_1)(20); //fixes the first argument and calls foo(10,20) + // sigc::group(&foo,10,sigc::_1)(20); //fixes the first argument and calls foo(10,20) std::bind(&foo_group1, 10, std::placeholders::_1)(20); util->check_result(result_stream, "foo_group1(int 10, int 20)"); - //sigc::group(&foo,sigc::_1,30)(40); //fixes the second argument and calls foo(40,30) + // sigc::group(&foo,sigc::_1,30)(40); //fixes the second argument and calls foo(40,30) std::bind(&foo_group1, std::placeholders::_1, 30)(40); util->check_result(result_stream, "foo_group1(int 40, int 30)"); // argument reordering ... - //sigc::group(&foo,sigc::_2,sigc::_1)(1,2); //calls foo(2,1) - std::bind(&foo_group1, std::placeholders::_2, std::placeholders::_1)(1,2); + // sigc::group(&foo,sigc::_2,sigc::_1)(1,2); //calls foo(2,1) + std::bind(&foo_group1, std::placeholders::_2, std::placeholders::_1)(1, 2); util->check_result(result_stream, "foo_group1(int 2, int 1)"); // argument hiding ... - //sigc::group(&foo,sigc::_1,sigc::_2)(1,2,3); //calls foo(1,2) - std::bind(&foo_group1, std::placeholders::_1, std::placeholders::_2)(1,2,3); + // sigc::group(&foo,sigc::_1,sigc::_2)(1,2,3); //calls foo(1,2) + std::bind(&foo_group1, std::placeholders::_1, std::placeholders::_2)(1, 2, 3); util->check_result(result_stream, "foo_group1(int 1, int 2)"); // functor composition ... - //sigc::group(&foo,sigc::_1,sigc::group(&bar,sigc::_2))(1,2); //calls foo(1,bar(2)) - std::bind(&foo_group1, std::placeholders::_1, std::bind(&bar_group1, std::placeholders::_2))(1,2); + // sigc::group(&foo,sigc::_1,sigc::group(&bar,sigc::_2))(1,2); //calls foo(1,bar(2)) + std::bind(&foo_group1, std::placeholders::_1, std::bind(&bar_group1, std::placeholders::_2))( + 1, 2); util->check_result(result_stream, "bar_group1(int 2) foo_group1(int 1, int 4)"); // algebraic expressions ... // sigc::group(&foo,sigc::_1*sigc::_2,sigc::_1/sigc::_2)(6,3); //calls foo(6*3,6/3) - [] (int x, int y) { foo_group1(x*y, x/y); }(6,3); + [](int x, int y) { foo_group1(x * y, x / y); }(6, 3); util->check_result(result_stream, "foo_group1(int 18, int 2)"); { - sigc::signal some_signal; - //some_signal.connect(sigc::group(&foo,sigc::_2)); - //some_signal.connect(std::bind(&foo_group2, std::placeholders::_2)); // does not compile (gcc 4.6.3) + sigc::signal some_signal; + // some_signal.connect(sigc::group(&foo,sigc::_2)); + // some_signal.connect(std::bind(&foo_group2, std::placeholders::_2)); // does not compile (gcc + // 4.6.3) some_signal.connect([](int, int y) { foo_group2(y); }); - some_signal.emit(1,2); + some_signal.emit(1, 2); util->check_result(result_stream, "foo_group2(int 2)"); } { int some_int = 0; - sigc::signal some_signal; - //some_signal.connect(sigc::group(&foo,sigc::ref(some_int))); - //some_signal.connect(std::bind(&foo_group3, std::ref(some_int))); // does not compile (gcc 4.6.3) - //some_signal.connect(sigc::bind(&foo_group3, sigc::ref(some_int))); // compiles, but we prefer std::bind() or C++11 lambda - some_signal.connect([&some_int](){ foo_group3(some_int); }); + sigc::signal some_signal; + // some_signal.connect(sigc::group(&foo,std::ref(some_int))); + // some_signal.connect(std::bind(&foo_group3, std::ref(some_int))); // does not compile (gcc + // 4.6.3) + // some_signal.connect(sigc::bind(&foo_group3, std::ref(some_int))); // compiles, but we prefer + // std::bind() or C++11 lambda + some_signal.connect([&some_int]() { foo_group3(some_int); }); some_signal.emit(); result_stream << " " << some_int; util->check_result(result_stream, "foo_group3(int 0) 1"); } { - //struct bar : public sigc::trackable {} some_bar; - sigc::signal some_signal; + // struct bar : public sigc::trackable {} some_bar; + sigc::signal some_signal; { bar_group4 some_bar; - //some_signal.connect(sigc::group(&foo,sigc::ref(some_bar))); + // some_signal.connect(sigc::group(&foo, std::ref(some_bar))); // disconnected automatically if some_bar goes out of scope - //some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect - //some_signal.connect(sigc::bind(&foo_group4, sigc::ref(some_bar))); // auto-disconnects, but we prefer C++11 lambda - some_signal.connect(sigc::track_obj([&some_bar](){ foo_group4(some_bar); }, some_bar)); + // some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect + // some_signal.connect(sigc::bind(&foo_group4, std::ref(some_bar))); // auto-disconnects, but + // we prefer C++11 lambda + some_signal.connect(sigc::track_object([&some_bar]() { foo_group4(some_bar); }, some_bar)); some_signal.emit(); util->check_result(result_stream, "foo_group4(bar_group4&)"); } diff --git a/tests/test_custom.cc b/tests/test_custom.cc index 8b4e0f6c..50e4df1b 100644 --- a/tests/test_custom.cc +++ b/tests/test_custom.cc @@ -1,10 +1,12 @@ +/* Copyright 2005 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + // Write your custom tests here so you don't have to think about how to compile // and execute your test code against the exact same library that you are // currently hacking. #include "testutilities.h" -#include -#include #include namespace @@ -13,7 +15,8 @@ std::ostringstream result_stream; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); diff --git a/tests/test_deduce_result_type.cc b/tests/test_deduce_result_type.cc deleted file mode 100644 index 423d8cd2..00000000 --- a/tests/test_deduce_result_type.cc +++ /dev/null @@ -1,76 +0,0 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team - * Assigned to public domain. Use as you wish without restriction. - */ - -#include "testutilities.h" -#include -#include -#include - -namespace -{ -std::ostringstream result_stream; - -template -void bar(T) -{ - result_stream << "unknown"; -} - -template <> -void bar(int) -{ - result_stream << "int"; -} - -template <> -void bar(double) -{ - result_stream << "double"; -} - -struct foo : public sigc::functor_base -{ - typedef double result_type; - - int operator()(int i = 1); - double operator()(const int&, int); -}; - -struct foo2 : public foo -{}; - -struct foo3 : public sigc::functor_base -{ - typedef int result_type; - - int operator()(int i = 1); - double operator()(const int&, int); -}; - -} // end anonymous namespace - -int main(int argc, char* argv[]) -{ - auto util = TestUtilities::get_instance(); - - if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - - bar(sigc::deduce_result_t()); - util->check_result(result_stream, "double"); - - bar(sigc::deduce_result_t()); - util->check_result(result_stream, "double"); - - bar(sigc::deduce_result_t()); - util->check_result(result_stream, "int"); - -#ifdef FAIL - bar(sigc::deduce_result_t()); - util->check_result(result_stream, "double"); -#endif - - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; -} diff --git a/tests/test_disconnect.cc b/tests/test_disconnect.cc index 048acbd0..28ff1e3f 100644 --- a/tests/test_disconnect.cc +++ b/tests/test_disconnect.cc @@ -1,32 +1,28 @@ -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include #include -#include -#include -#include -#include -//The Tru64 compiler seems to need this to avoid an unresolved symbol -//See bug #161503 -#include +// The Tru64 compiler seems to need this to avoid an unresolved symbol +// See bug #161503 namespace { std::ostringstream result_stream; -int foo(int i) +int +foo(int i) { result_stream << "foo(" << i << ") "; return 1; } -int bar(double i) +int +bar(double i) { result_stream << "bar(" << i << ") "; return 1; @@ -41,7 +37,8 @@ struct A : public sigc::trackable } }; -void good_bye_world() +void +good_bye_world() { result_stream << "Good bye world!"; } @@ -50,88 +47,85 @@ struct B : public sigc::trackable { B() { - sig.connect(sigc::mem_fun(this, &B::destroy)); - sig.connect(sigc::mem_fun(this, &B::boom)); + sig.connect(sigc::mem_fun(*this, &B::destroy)); + sig.connect(sigc::mem_fun(*this, &B::boom)); sig.connect(sigc::ptr_fun(&good_bye_world)); } - void destroy() // Calling destroy() during signal emission seems weird! - { // However, if this works, anything will work! - delete this; // valgrind reports a small memory leak, that's all. + void destroy() // Calling destroy() during signal emission seems weird! + { // However, if this works, anything will work! + delete this; // valgrind reports a small memory leak, that's all. } - void boom() - { - result_stream << "boom!"; - } + void boom() { result_stream << "boom!"; } - void emit() - { - sig.emit(); - } + void emit() { sig.emit(); } - sigc::signal sig; + sigc::signal sig; }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - sigc::signal sig; - sigc::signal::iterator confoo; - sigc::signal::iterator conbar; - sigc::connection cona; // connection objects are safe to use beyond the life time of a signal. + sigc::signal sig; + sigc::connection confoo; + sigc::connection conbar; + sigc::connection cona; // connection objects are safe to use beyond the life time of a signal. { A a; - sig.connect(sigc::mem_fun1(&a, &A::foo)); - confoo = sig.connect(sigc::ptr_fun1(&foo)); - conbar = sig.connect(sigc::ptr_fun1(&bar)); + sig.connect(sigc::mem_fun(a, &A::foo)); + confoo = sig.connect(sigc::ptr_fun(&foo)); + conbar = sig.connect(sigc::ptr_fun(&bar)); result_stream << "sig is connected to A::foo, foo, bar (size=" << sig.size() << "): "; sig(1); - util->check_result(result_stream, - "sig is connected to A::foo, foo, bar (size=3): A::foo(1) foo(1) bar(1) "); - } // auto disconnection! iterators stay valid after disconnections. + util->check_result( + result_stream, "sig is connected to A::foo, foo, bar (size=3): A::foo(1) foo(1) bar(1) "); + } // auto disconnection! iterators stay valid after disconnections. result_stream << "sig is connected to foo, bar (size=" << sig.size() << "): "; sig(2); util->check_result(result_stream, "sig is connected to foo, bar (size=2): foo(2) bar(2) "); - A a; // iterators stay valid after further connections. - cona = sig.slots().insert(conbar, sigc::mem_fun1(&a, &A::foo)); + A a; // iterators stay valid after further connections. + cona = sig.connect(sigc::mem_fun(a, &A::foo)); result_stream << "sig is connected to foo, A::foo, bar (size=" << sig.size() << "): "; sig(3); - util->check_result(result_stream, - "sig is connected to foo, A::foo, bar (size=3): foo(3) A::foo(3) bar(3) "); + util->check_result( + result_stream, "sig is connected to foo, A::foo, bar (size=3): foo(3) bar(3) A::foo(3) "); - conbar->disconnect(); // manual disconnection + conbar.disconnect(); // manual disconnection result_stream << "sig is connected to foo, A::foo (size=" << sig.size() << "): "; sig(4); util->check_result(result_stream, "sig is connected to foo, A::foo (size=2): foo(4) A::foo(4) "); - confoo->disconnect(); // manual disconnection + confoo.disconnect(); // manual disconnection result_stream << "sig is connected to A::foo (size=" << sig.size() << "): "; sig(5); util->check_result(result_stream, "sig is connected to A::foo (size=1): A::foo(5) "); - cona.disconnect(); // manual disconnection + cona.disconnect(); // manual disconnection result_stream << "sig is empty (size=" << sig.size() << "): "; sig(6); util->check_result(result_stream, "sig is empty (size=0): "); - cona.disconnect(); // already disconnected -> legal with connection objects, however, nothing happens ... + cona.disconnect(); // already disconnected -> legal with connection objects, however, nothing + // happens ... { A a2; - sig.connect(sigc::compose(sigc::mem_fun(&a2, &A::foo), &foo)); + sig.connect(sigc::compose(sigc::mem_fun(a2, &A::foo), &foo)); result_stream << "sig is connected to compose(A::foo, foo) (size=" << sig.size() << "): "; sig(7); - util->check_result(result_stream, "sig is connected to compose(A::foo, foo) (size=1): foo(7) A::foo(1) "); + util->check_result( + result_stream, "sig is connected to compose(A::foo, foo) (size=1): foo(7) A::foo(1) "); } result_stream << "sig is empty (size=" << sig.size() << "): "; sig(8); @@ -139,11 +133,13 @@ int main(int argc, char* argv[]) { // A slot# within a slot A a2; - sigc::slot1 setter = sigc::mem_fun(&a2, &A::foo); + sigc::slot setter = sigc::mem_fun(a2, &A::foo); sig.connect(sigc::compose(setter, &foo)); - result_stream << "sig is connected to compose(slot1(A::foo), foo) (size=" << sig.size() << "): "; + result_stream << "sig is connected to compose(slot1(A::foo), foo) (size=" << sig.size() + << "): "; sig(9); - util->check_result(result_stream, "sig is connected to compose(slot1(A::foo), foo) (size=1): foo(9) A::foo(1) "); + util->check_result( + result_stream, "sig is connected to compose(slot1(A::foo), foo) (size=1): foo(9) A::foo(1) "); } result_stream << "sig is empty (size=" << sig.size() << "): "; sig(10); @@ -151,18 +147,19 @@ int main(int argc, char* argv[]) { // A slot within a slot A a2; - sigc::slot setter = sigc::mem_fun(&a2, &A::foo); + sigc::slot setter = sigc::mem_fun(a2, &A::foo); sig.connect(sigc::compose(setter, &foo)); result_stream << "sig is connected to compose(slot(A::foo), foo) (size=" << sig.size() << "): "; sig(11); - util->check_result(result_stream, "sig is connected to compose(slot(A::foo), foo) (size=1): foo(11) A::foo(1) "); + util->check_result( + result_stream, "sig is connected to compose(slot(A::foo), foo) (size=1): foo(11) A::foo(1) "); } result_stream << "sig is empty (size=" << sig.size() << "): "; sig(12); util->check_result(result_stream, "sig is empty (size=0): "); result_stream << "deleting a signal during emission... "; - auto b = new B; + auto b = new B; // This is deleted by B::destroy(). b->emit(); util->check_result(result_stream, "deleting a signal during emission... Good bye world!"); diff --git a/tests/test_disconnect_during_emit.cc b/tests/test_disconnect_during_emit.cc index 07232426..b746c21f 100644 --- a/tests/test_disconnect_during_emit.cc +++ b/tests/test_disconnect_during_emit.cc @@ -1,4 +1,4 @@ -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ @@ -29,7 +29,8 @@ class HandlerClass : public sigc::trackable } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -38,7 +39,7 @@ int main(int argc, char* argv[]) HandlerClass instance; - sigc::signal signal_test; + sigc::signal signal_test; connection = signal_test.connect(sigc::mem_fun(instance, &HandlerClass::handler)); result_stream << "Number of signal handlers before signal emission: " << signal_test.size(); util->check_result(result_stream, "Number of signal handlers before signal emission: 1"); diff --git a/tests/test_exception_catch.cc b/tests/test_exception_catch.cc index f8f6e02e..29c8b320 100644 --- a/tests/test_exception_catch.cc +++ b/tests/test_exception_catch.cc @@ -1,22 +1,16 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include -#include namespace { std::ostringstream result_stream; -struct f : public sigc::functor_base +struct f { - typedef int result_type; - int operator()(int i) { result_stream << "f(int " << i << ") "; @@ -24,10 +18,8 @@ struct f : public sigc::functor_base } }; -struct g : public sigc::functor_base +struct g { - typedef int result_type; - int operator()() { result_stream << "g() "; @@ -35,10 +27,8 @@ struct g : public sigc::functor_base } }; -struct g_void : public sigc::functor_base +struct g_void { - typedef void result_type; - void operator()() { result_stream << "g_void() "; @@ -54,7 +44,7 @@ struct my_catch { throw; } - catch (std::range_error e) // catch what types we know + catch (const std::range_error& e) // catch what types we know { result_stream << "caught " << e.what(); } @@ -63,9 +53,27 @@ struct my_catch } }; +struct my_catch_void +{ + void operator()() + { + try + { + throw; + } + catch (const std::range_error& e) // catch what types we know + { + result_stream << "caught " << e.what(); + } + + // all else continues out. + } +}; + } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -78,7 +86,7 @@ int main(int argc, char* argv[]) result_stream << sigc::exception_catch(g(), my_catch())(); util->check_result(result_stream, "g() caught out of range 1"); - sigc::exception_catch(g_void(), my_catch())(); // void test + sigc::exception_catch(g_void(), my_catch_void())(); // void test util->check_result(result_stream, "g_void() caught out of range "); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; diff --git a/tests/test_functor_trait.cc b/tests/test_functor_trait.cc deleted file mode 100644 index bf3b26e4..00000000 --- a/tests/test_functor_trait.cc +++ /dev/null @@ -1,98 +0,0 @@ -/* Copyright 2002, The libsigc++ Development Team - * Assigned to public domain. Use as you wish without restriction. - */ - -#include "testutilities.h" -#include -#include -#include -#include -#include -#include - -namespace -{ -std::ostringstream result_stream; - -class trackable {}; - -struct A : public trackable { A() {} }; - -template ::value> -struct with_trackable; - -template -struct with_trackable -{ - static void perform(const T_type&) - { - result_stream << "other "; - } -}; - -template -struct with_trackable -{ - static void perform(const T_type&) - { - result_stream << "trackable "; - } - - static void perform(T_type*) - { - result_stream << "trackable* "; - } - - static void perform(const T_type*) - { - result_stream << "const trackable* "; - } -}; - -struct print -{ - void operator()(int i) const - { - result_stream << "int: " << i << " "; - } - - template - void operator()(const T& t) const - { - with_trackable::perform(t); - } -}; - -void foo(int, int, int) -{} - -void bar(int) -{} - -} // end anonymous namespace - -int main(int argc, char* argv[]) -{ - auto util = TestUtilities::get_instance(); - - if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - - int i = 1; - int j = 2; - int k = 3; - A a; - result_stream << "hit all targets: "; - sigc::visit_each(print(), sigc::compose(sigc::bind(sigc::ptr_fun3(&foo), sigc::ref(a), i), sigc::ptr_fun1(&bar))); - util->check_result(result_stream, "hit all targets: other trackable int: 1 other "); - - result_stream << "hit all ints: "; - sigc::visit_each_type(print(), sigc::compose(sigc::bind(sigc::ptr_fun3(&foo), sigc::ref(a), j),sigc::ptr_fun1(&bar))); - util->check_result(result_stream, "hit all ints: int: 2 "); - - result_stream << "hit all trackable: "; - sigc::visit_each_type(print(), sigc::compose(sigc::bind(sigc::ptr_fun3(&foo), sigc::ref(a), k),sigc::ptr_fun1(&bar))); - util->check_result(result_stream, "hit all trackable: trackable "); - - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; -} diff --git a/tests/test_hide.cc b/tests/test_hide.cc index c1cdad2f..bec7def4 100644 --- a/tests/test_hide.cc +++ b/tests/test_hide.cc @@ -1,22 +1,16 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include namespace { std::ostringstream result_stream; -struct foo : public sigc::functor_base +struct foo { - // choose a type that can hold all return values - typedef int result_type; - int operator()() { result_stream << "foo() "; @@ -30,26 +24,20 @@ struct foo : public sigc::functor_base } }; -struct foo_void : public sigc::functor_base +struct foo_void { - typedef void result_type; - - void operator()() - { - result_stream << "foo_void()"; - } + void operator()() { result_stream << "foo_void()"; } }; } // end anonymous namespace -namespace sigc { SIGC_FUNCTOR_TRAIT(foo,bool) } - -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + return TestUtilities::get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; result_stream << sigc::hide<0>(foo())(1, 2); util->check_result(result_stream, "foo(int 2) 3"); @@ -66,5 +54,5 @@ int main(int argc, char* argv[]) sigc::hide(foo_void())(1); // void test util->check_result(result_stream, "foo_void()"); - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + return TestUtilities::get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_limit_reference.cc b/tests/test_limit_reference.cc index d72efd18..a115d6dc 100644 --- a/tests/test_limit_reference.cc +++ b/tests/test_limit_reference.cc @@ -1,38 +1,43 @@ +/* Copyright 2005 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + #include "testutilities.h" #include -#include -#include namespace { std::ostringstream result_stream; -class Base - : virtual public sigc::trackable +class Base : virtual public sigc::trackable { +public: + Base() {} + + Base(const Base& src) = default; + Base& operator=(const Base& src) = default; + Base(Base&& src) = delete; + Base& operator=(Base&& src) = delete; }; class Base2 { public: - virtual ~Base2() - {} + virtual ~Base2() {} }; class Derived - : virtual public Base, - public Base2 +: virtual public Base +, public Base2 { public: - void method() - { - result_stream << "method()"; - } + void method() { result_stream << "method()"; } }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -40,17 +45,15 @@ int main(int argc, char* argv[]) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; auto instance = new Derived(); - sigc::slot handler = sigc::mem_fun(instance, &Derived::method); + sigc::slot handler = sigc::mem_fun(*instance, &Derived::method); handler(); util->check_result(result_stream, "method()"); - auto param = - sigc::bind(sigc::slot(), sigc::ref(*instance)); + sigc::slot param = sigc::bind(sigc::slot(), std::ref(*instance)); param(); util->check_result(result_stream, ""); - auto ret = - sigc::bind_return(sigc::slot(), sigc::ref(*instance)); + sigc::slot ret = sigc::bind_return(sigc::slot(), std::ref(*instance)); ret(); util->check_result(result_stream, ""); diff --git a/tests/test_mem_fun.cc b/tests/test_mem_fun.cc index 32e568bf..ee344afb 100644 --- a/tests/test_mem_fun.cc +++ b/tests/test_mem_fun.cc @@ -1,31 +1,21 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include - -//TODO: put something like #ifndef FORTE (some older version, I think) or AIX xlC... #else ... #endif around: -#define ENABLE_TEST_OF_OVERLOADED_FUNCTIONS 0 namespace { + +TestUtilities* util = nullptr; std::ostringstream result_stream; struct test { - void foo(short i1) - { - result_stream << "test::foo(short " << i1 << ')'; - } + void foo(short i1) { result_stream << "test::foo(short " << i1 << ')'; } - void foo_const(int i1) const - { - result_stream << "test::foo_const(int " << i1 << ')'; - } + void foo_const(int i1) const { result_stream << "test::foo_const(int " << i1 << ')'; } void foo_volatile(float i1) volatile { @@ -37,17 +27,12 @@ struct test result_stream << "test::foo_const_volatile(double " << i1 << ')'; } - void foo_overloaded(char i1) - { - result_stream << "test::foo_overloaded(char " << int(i1) << ')'; - } + void foo_overloaded(char i1) { result_stream << "test::foo_overloaded(char " << int(i1) << ')'; } -#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS void foo_overloaded(short i1) { result_stream << "test::foo_overloaded(short " << (int)i1 << ')'; } -#endif double foo_overloaded(int i1, int i2) { @@ -58,105 +43,143 @@ struct test } // end anonymous namespace -int main(int argc, char* argv[]) +void +test_non_const() { - auto util = TestUtilities::get_instance(); + test t; + sigc::mem_fun (&test::foo)(t, 1); + util->check_result(result_stream, "test::foo(short 1)"); +} - if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; +void +test_const() +{ + test t; + sigc::mem_fun (&test::foo_const)(t, 2); + util->check_result(result_stream, "test::foo_const(int 2)"); +} - { /* test non-const */ - test t; - sigc::mem_fun(&test::foo)(t, 1); // on reference - util->check_result(result_stream, "test::foo(short 1)"); +void +test_const_with_const_object() +{ + const auto t = test(); + sigc::mem_fun (&test::foo_const)(t, 3); + util->check_result(result_stream, "test::foo_const(int 3)"); +} - sigc::mem_fun(&test::foo)(&t, 1); // on pointer - util->check_result(result_stream, "test::foo(short 1)"); - } - { /* test const */ - test t; - sigc::mem_fun(&test::foo_const)(t, 2); - util->check_result(result_stream, "test::foo_const(int 2)"); +void +test_non_const_volatile() +{ + test t; + sigc::mem_fun (&test::foo_volatile)(t, 4); + util->check_result(result_stream, "test::foo_volatile(float 4)"); +} - sigc::mem_fun(&test::foo_const)(&t, 2); - util->check_result(result_stream, "test::foo_const(int 2)"); - } - { /* test const with const object */ - const auto t = test(); - sigc::mem_fun(&test::foo_const)(t, 3); - util->check_result(result_stream, "test::foo_const(int 3)"); +void +test_const_volatile() +{ + test t; + sigc::mem_fun (&test::foo_const_volatile)(t, 5); + util->check_result(result_stream, "test::foo_const_volatile(double 5)"); +} - sigc::mem_fun(&test::foo_const)(&t, 3); - util->check_result(result_stream, "test::foo_const(int 3)"); - } - { /* test non-const volatile */ - test t; - sigc::mem_fun(&test::foo_volatile)(t, 4); // on reference - util->check_result(result_stream, "test::foo_volatile(float 4)"); +void +test_const_volatile_with_const_object() +{ + const auto t = test(); + sigc::mem_fun (&test::foo_const_volatile)(t, 6); + util->check_result(result_stream, "test::foo_const_volatile(double 6)"); +} - sigc::mem_fun(&test::foo_volatile)(&t, 4); // on pointer - util->check_result(result_stream, "test::foo_volatile(float 4)"); - } - { /* test const volatile */ - test t; - sigc::mem_fun(&test::foo_const_volatile)(t, 5); // on reference - util->check_result(result_stream, "test::foo_const_volatile(double 5)"); +void +test_overloaded() +{ + test t; - sigc::mem_fun(&test::foo_const_volatile)(&t, 5); // on pointer - util->check_result(result_stream, "test::foo_const_volatile(double 5)"); - } - { /* test const volatile with const object */ - const auto t = test(); - sigc::mem_fun(&test::foo_const_volatile)(t, 6); // on reference - util->check_result(result_stream, "test::foo_const_volatile(double 6)"); + // We need to specify the types when using overloaded functions. - sigc::mem_fun(&test::foo_const_volatile)(&t, 6); // on pointer - util->check_result(result_stream, "test::foo_const_volatile(double 6)"); - } -#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS - { /* test overloaded */ - test t; - sigc::mem_fun1(&test::foo_overloaded)(&t, 7); - util->check_result(result_stream, "test::foo_overloaded(char 7)"); + sigc::mem_fun (&test::foo_overloaded)(t, 7); + util->check_result(result_stream, "test::foo_overloaded(char 7)"); - sigc::mem_fun1(&test::foo_overloaded)(&t, 7); - util->check_result(result_stream, "test::foo_overloaded(short 7)"); + sigc::mem_fun (&test::foo_overloaded)(t, 7); + util->check_result(result_stream, "test::foo_overloaded(short 7)"); - //sigc::mem_fun1(&test::foo_overloaded)(&t, 7); - //util->check_result(result_stream, "test::foo_overloaded(short 7)"); + sigc::mem_fun (&test::foo_overloaded)(t, 7, 8); + util->check_result(result_stream, "test::foo_overloaded(int 7, int 8)"); +} - sigc::mem_fun2(&test::foo_overloaded)(&t, 7, 8); - util->check_result(result_stream, "test::foo_overloaded(int 7, int 8)"); - } -#endif - { /* test bound */ - test t; - sigc::mem_fun(t, &test::foo)(9); - util->check_result(result_stream, "test::foo(short 9)"); +void +test_bound() +{ + test t; + sigc::mem_fun(t, &test::foo)(9); + util->check_result(result_stream, "test::foo(short 9)"); - sigc::mem_fun(&t, &test::foo)(9); - util->check_result(result_stream, "test::foo(short 9)"); + sigc::mem_fun(t, &test::foo)(9); + util->check_result(result_stream, "test::foo(short 9)"); - sigc::mem_fun(t, &test::foo_const)(9); - util->check_result(result_stream, "test::foo_const(int 9)"); + sigc::mem_fun(t, &test::foo_const)(9); + util->check_result(result_stream, "test::foo_const(int 9)"); - sigc::mem_fun(&t, &test::foo_const)(9); - util->check_result(result_stream, "test::foo_const(int 9)"); + sigc::mem_fun(t, &test::foo_const)(9); + util->check_result(result_stream, "test::foo_const(int 9)"); - sigc::mem_fun(t, &test::foo_volatile)(9); - util->check_result(result_stream, "test::foo_volatile(float 9)"); + sigc::mem_fun(t, &test::foo_volatile)(9); + util->check_result(result_stream, "test::foo_volatile(float 9)"); - sigc::mem_fun(&t, &test::foo_volatile)(9); - util->check_result(result_stream, "test::foo_volatile(float 9)"); + sigc::mem_fun(t, &test::foo_volatile)(9); + util->check_result(result_stream, "test::foo_volatile(float 9)"); -#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS - sigc::mem_fun2(t, &test::foo_overloaded)(9, 10); - util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)"); + sigc::mem_fun(t, &test::foo_overloaded)(9, 10); + util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)"); +} + +class TestAutoDisconnect : public sigc::trackable +{ +public: + void foo() { result_stream << "TestAutoDisconnect::foo() called."; } +}; + +void +test_auto_disconnect() +{ + // Check that slot doesn't try to call a method on a destroyed instance, + // when the instance's class derives from trackable. + sigc::slot slot_of_member_method; + { + TestAutoDisconnect t; + slot_of_member_method = sigc::mem_fun(t, &TestAutoDisconnect::foo); - sigc::mem_fun2(&t, &test::foo_overloaded)(9, 10); - util->check_result(result_stream, "test::foo_overloaded(int 9, int 10)"); -#endif + // The method should be called: + slot_of_member_method(); + util->check_result(result_stream, "TestAutoDisconnect::foo() called."); } + // The method should not be called: + slot_of_member_method(); + util->check_result(result_stream, ""); +} + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_non_const(); + test_const(); + test_const_with_const_object(); + test_non_const_volatile(); + test_const_volatile(); + test_const_volatile_with_const_object(); + + test_overloaded(); + + test_bound(); + + test_auto_disconnect(); + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_member_method_trait.cc b/tests/test_member_method_trait.cc new file mode 100644 index 00000000..bc5c4502 --- /dev/null +++ b/tests/test_member_method_trait.cc @@ -0,0 +1,101 @@ +/* Copyright 2016 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + +#include +#include +#include + +namespace +{ + +class Something +{ +public: + void some_func(int) {} + + void some_const_func(int) const {} + + void some_volatile_func(int) volatile {} + + void some_const_volatile_func(int) const volatile {} + + int some_int_func() { return 1; } + + bool some_bool_func() { return true; } +}; + +} // end anonymous namespace + +void +test_member_method_is_const() +{ + static_assert(!sigc::internal::member_method_is_const::value, + "member_method_is_const failed to identify a non-const member method."); + + static_assert( + !sigc::internal::member_method_is_const::value, + "member_method_is_const failed to identify a non-const member method."); + + static_assert( + sigc::internal::member_method_is_const::value, + "member_method_is_const failed to identify a const member method."); + + static_assert( + sigc::internal::member_method_is_const::value, + "member_method_is_const failed to identify a const member method."); +} + +void +test_member_method_is_volatile() +{ + static_assert(!sigc::internal::member_method_is_volatile::value, + "member_method_is_const failed to identify a non-volatile member method."); + + static_assert( + !sigc::internal::member_method_is_volatile::value, + "member_method_is_const failed to identify a non-volatile member method."); + + static_assert( + sigc::internal::member_method_is_volatile::value, + "member_method_is_const failed to identify a volatile member method."); + + static_assert(sigc::internal::member_method_is_volatile< + decltype(&Something::some_const_volatile_func)>::value, + "member_method_is_const failed to identify a volatile member method."); +} + +void +test_member_method_class_type() +{ + static_assert( + std::is_same::type, + Something>::value, + "member_method_class_type failed to identify the class type."); +} + +void +test_member_method_result_type() +{ + static_assert( + std::is_same::type, + int>::value, + "member_method_result_type failed to identify the result type."); + + static_assert( + std::is_same::type, + bool>::value, + "member_method_result_type failed to identify the result type."); +} + +int +main() +{ + test_member_method_is_const(); + test_member_method_is_volatile(); + + test_member_method_class_type(); + test_member_method_result_type(); + + return EXIT_SUCCESS; +} diff --git a/tests/test_ptr_fun.cc b/tests/test_ptr_fun.cc index d3cbf51d..6c29437b 100644 --- a/tests/test_ptr_fun.cc +++ b/tests/test_ptr_fun.cc @@ -1,44 +1,47 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" -#include #include -#include - -//TODO: put something like #ifndef FORTE ... #else ... #endif around: -#define ENABLE_TEST_OF_OVERLOADED_FUNCTIONS 0 namespace { std::ostringstream result_stream; +// TODO: This works with clang++ (when we specify the return type, such as +// int or void, but doesn't work with g++. +/* int foo() { result_stream << "foo()"; return 1; } +*/ -void foo(int i1) +void +foo(int i1) { result_stream << "foo(int " << i1 << ")"; } -#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS -void bar(char i1) +void +bar(char i1) { result_stream << "bar(char " << (int)i1 << ")"; } -#endif -void bar(float i1) +// Note: This doesn't work with some older versions of g++, +// even when we specify the return type. +// Hopefully those g++ versions are old enough now. +void +bar(float i1) { result_stream << "bar(float " << i1 << ")"; } -double bar(int i1, int i2) +double +bar(int i1, int i2) { result_stream << "bar(int " << i1 << ", int " << i2 << ")"; return 1.0f; @@ -46,42 +49,44 @@ double bar(int i1, int i2) struct test { - static void foo() - { - result_stream << "test::foo()"; - } + static void foo() { result_stream << "test::foo()"; } }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - sigc::ptr_fun0(&foo)(); - util->check_result(result_stream, "foo()"); + // Test use of overloaded functions that differ by number of parameters + // and by return type + // TODO: This works with clang++ (when we specify the return type, such as + // int or void, but doesn't work with g++. + // sigc::ptr_fun(&foo)(); + // util->check_result(result_stream, "foo()"); - sigc::ptr_fun1(&foo)(1); + sigc::ptr_fun (&foo)(1); util->check_result(result_stream, "foo(int 1)"); -#if ENABLE_TEST_OF_OVERLOADED_FUNCTIONS - sigc::ptr_fun1(&bar)(2); + // Test use of overloaded functions that differ by parameter type: + sigc::ptr_fun (&bar)(2); util->check_result(result_stream, "bar(char 2)"); - sigc::ptr_fun1(&bar)(2.0f); - util->check_result(result_stream, "bar(float 2)"); -#else - sigc::ptr_fun1(&bar)(2.0f); + sigc::ptr_fun (&bar)(2.0f); util->check_result(result_stream, "bar(float 2)"); -#endif - sigc::ptr_fun2(&bar)(3, 5); + // int or void, but doesn't work with g++. + // sigc::ptr_fun(&bar)(2.0f); + // util->check_result(result_stream, "bar(float 2)"); + + sigc::ptr_fun (&bar)(3, 5); util->check_result(result_stream, "bar(int 3, int 5)"); - sigc::ptr_fun(&test::foo)(); + sigc::ptr_fun (&test::foo)(); util->check_result(result_stream, "test::foo()"); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; diff --git a/tests/test_retype.cc b/tests/test_retype.cc index 848731f5..7376bf87 100644 --- a/tests/test_retype.cc +++ b/tests/test_retype.cc @@ -1,15 +1,14 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include namespace { + +TestUtilities* util = nullptr; std::ostringstream result_stream; struct foo : public sigc::trackable @@ -27,45 +26,90 @@ struct foo : public sigc::trackable } }; -void bar(short s) +void +bar(short s) { result_stream << "bar(short " << s << ")"; } -} // end anonymous namespace - -int main(int argc, char* argv[]) +void +test_member_int() { - auto util = TestUtilities::get_instance(); - - if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - foo foo_; result_stream << sigc::retype(sigc::mem_fun(foo_, &foo::test_int))(1.234f); util->check_result(result_stream, "foo::test_int(int 1) 1.5"); +} +void +test_member_float() +{ + foo foo_; result_stream << sigc::retype(sigc::mem_fun(foo_, &foo::test_float))(5); util->check_result(result_stream, "foo::test_float(float 5) 25"); +} +void +test_ptr_fun() +{ sigc::retype(sigc::ptr_fun(&bar))(6.789f); util->check_result(result_stream, "bar(short 6)"); +} - sigc::slot s1 = sigc::retype(sigc::mem_fun(foo_, &foo::test_int)); - sigc::slot s2 = sigc::retype(sigc::mem_fun(foo_, &foo::test_float)); - sigc::slot s3 = sigc::retype(sigc::ptr_fun(&bar)); +void +test_member_int_with_slot() +{ + foo foo_; + sigc::slot s1 = sigc::retype(sigc::mem_fun(foo_, &foo::test_int)); result_stream << s1(1.234f); util->check_result(result_stream, "foo::test_int(int 1) 1.5"); +} +void +test_member_float_with_slot() +{ + foo foo_; + sigc::slot s2 = sigc::retype(sigc::mem_fun(foo_, &foo::test_float)); result_stream << s2(5); util->check_result(result_stream, "foo::test_float(float 5) 25"); +} +void +test_ptr_fun_with_slot() +{ + sigc::slot s3 = sigc::retype(sigc::ptr_fun(&bar)); s3(6.789); util->check_result(result_stream, "bar(short 6)"); +} - s2 = sigc::retype(s1); +void +test_retype_slot() +{ + foo foo_; + sigc::slot s1 = sigc::retype(sigc::mem_fun(foo_, &foo::test_int)); + sigc::slot s2 = sigc::retype(s1); result_stream << s2(5); util->check_result(result_stream, "foo::test_int(int 5) 7.5"); +} + +} // end anonymous namespace + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_member_int(); + test_member_float(); + test_ptr_fun(); + + test_member_int_with_slot(); + test_member_float_with_slot(); + test_ptr_fun_with_slot(); + + test_retype_slot(); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_retype_return.cc b/tests/test_retype_return.cc index 9026e326..ded28239 100644 --- a/tests/test_retype_return.cc +++ b/tests/test_retype_return.cc @@ -1,22 +1,17 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include -#include namespace { std::ostringstream result_stream; -struct foo : public sigc::functor_base +struct foo { - typedef float result_type; - float operator()(int i) { result_stream << "foo(int " << i << ") "; @@ -30,10 +25,8 @@ struct foo : public sigc::functor_base } }; -struct bar : public sigc::trackable, public sigc::functor_base +struct bar : public sigc::trackable { - typedef int result_type; - int operator()(int i) { result_stream << "bar(int " << i << ")"; @@ -43,7 +36,8 @@ struct bar : public sigc::trackable, public sigc::functor_base } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -55,7 +49,7 @@ int main(int argc, char* argv[]) util->check_result(result_stream, "foo(float 1.234) 6"); // retype_return / hide_return - sigc::slot sl; + sigc::slot sl; sl = sigc::retype_return(bar()); sl(5); util->check_result(result_stream, "bar(int 5)"); diff --git a/tests/test_rvalue_ref.cc b/tests/test_rvalue_ref.cc new file mode 100644 index 00000000..344a8563 --- /dev/null +++ b/tests/test_rvalue_ref.cc @@ -0,0 +1,100 @@ +#include "testutilities.h" +#include +#include + +struct MoveableStruct +{ +}; + +namespace +{ +TestUtilities* util = nullptr; +std::ostringstream result_stream; + +struct foo +{ + void operator()(MoveableStruct&& /* x */) { result_stream << "foo(MoveableStruct&&)"; } +}; + +struct A +{ + void foo(MoveableStruct&&) { result_stream << "A::foo(MoveableStruct&&)"; } +}; + +void +boo(MoveableStruct&&) +{ + result_stream << "boo(MoveableStruct&&)"; +} + +} // end anonymous namespace + +void +test_signal() +{ + sigc::signal signal; + foo f; + signal.connect(f); + MoveableStruct x; + signal(std::move(x)); + util->check_result(result_stream, "foo(MoveableStruct&&)"); +} + +void +test_slot() +{ + sigc::slot slot; + foo f; + slot = f; + MoveableStruct x; + slot(std::move(x)); + util->check_result(result_stream, "foo(MoveableStruct&&)"); +} + +void +test_mem_fun() +{ + sigc::slot slot; + A a; + slot = sigc::mem_fun(&A::foo); + MoveableStruct x; + slot(a, std::move(x)); + util->check_result(result_stream, "A::foo(MoveableStruct&&)"); +} + +void +test_bound_mem_fun() +{ + sigc::slot slot; + A a; + slot = sigc::mem_fun(a, &A::foo); + MoveableStruct x; + slot(std::move(x)); + util->check_result(result_stream, "A::foo(MoveableStruct&&)"); +} + +void +test_ptr_fun() +{ + sigc::slot slot; + slot = sigc::ptr_fun(&boo); + MoveableStruct x; + slot(std::move(x)); + util->check_result(result_stream, "boo(MoveableStruct&&)"); +} + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_signal(); + test_slot(); + test_bound_mem_fun(); + test_mem_fun(); + test_ptr_fun(); + + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; +} // end main() diff --git a/tests/test_scoped_connection.cc b/tests/test_scoped_connection.cc new file mode 100644 index 00000000..520197fc --- /dev/null +++ b/tests/test_scoped_connection.cc @@ -0,0 +1,214 @@ +/* Copyright 2023, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + +#include "testutilities.h" +#include +#include +#include +#include +#include + +// Test the expected special members and conversions, esp. NOT copyable BUT movable. +static_assert( std::is_nothrow_default_constructible_v); +static_assert(!std::is_copy_constructible_v ); +static_assert(!std::is_copy_assignable_v ); +static_assert( std::is_nothrow_move_constructible_v ); +static_assert( std::is_move_assignable_v ); +static_assert( std::is_nothrow_swappable_v ); +// TODO: C++20: Test the stronger std::is_nothrow_convertible_v; it should pass. +static_assert( std::is_convertible_v); +static_assert(!std::is_convertible_v); +static_assert( std::is_assignable_v ); +static_assert(!std::is_assignable_v ); + +namespace +{ +std::ostringstream result_stream; + +int +foo(int i) +{ + result_stream << "foo(" << i << ") "; + return 1; +} + +int +bar(double i) +{ + result_stream << "bar(" << i << ") "; + return 1; +} + +struct A : public sigc::trackable +{ + int foo(int i) + { + result_stream << "A::foo(" << i << ") "; + return 1; + } +}; + +} // end anonymous namespace + +int +main(int argc, char* argv[]) +{ + auto util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + sigc::signal sig; + sigc::connection confoo; + sigc::connection conbar; + sigc::connection cona; + + { + A a; + sig.connect(sigc::mem_fun(a, &A::foo)); + conbar = sig.connect(&bar); + confoo = sig.connect_first(&foo); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(1); + util->check_result( + result_stream, "sig is connected to (size=3): foo(1) A::foo(1) bar(1) "); + } + // normal connections are still connected. mem_fun disconnected via trackable. + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(2); + util->check_result(result_stream, "sig is connected to (size=2): foo(2) bar(2) "); + + { + A a; + sig.connect(sigc::mem_fun(a, &A::foo)); + sigc::scoped_connection sconfoo = sig.connect(&foo); + sigc::scoped_connection sconbar = sig.connect_first(&bar); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(3); + util->check_result( + result_stream, "sig is connected to (size=5): bar(3) foo(3) bar(3) A::foo(3) foo(3) "); + } + // scoped connections are now disconnected. + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(4); + util->check_result(result_stream, "sig is connected to (size=2): foo(4) bar(4) "); + + // copying connection to a scoped connection disconnects when latter destroyed + // copy-constructor: + { + sigc::scoped_connection sconfoo = confoo; + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(5); + util->check_result( + result_stream, "sig is connected to (size=2): foo(5) bar(5) "); + } + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(6); + util->check_result( + result_stream, "sig is connected to (size=1): bar(6) "); + // copy-assignment: + confoo = sig.connect(&foo); + { + sigc::scoped_connection sconfoo = sig.connect(&bar); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(7); + util->check_result( + result_stream, "sig is connected to (size=3): bar(7) foo(7) bar(7) "); + // copy-assignment disconnects currently held connection & replaces with new + sconfoo = confoo; + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(8); + util->check_result( + result_stream, "sig is connected to (size=2): bar(8) foo(8) "); + } + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(9); + util->check_result( + result_stream, "sig is connected to (size=1): bar(9) "); + + // moving scoped_connection transfers ownership/disconnection to destination + // move-constructor: + { + auto src = std::make_unique(sig.connect(&foo)); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(10); + util->check_result( + result_stream, "sig is connected to (size=2): bar(10) foo(10) "); + + sigc::scoped_connection dst = std::move(*src); + src.reset(); // This will NOT disconnect from foo() + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(11); + util->check_result( + result_stream, "sig is connected to (size=2): bar(11) foo(11) "); + } + + // move-assignment: + { + auto src = std::make_unique(sig.connect(&foo)); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(12); + util->check_result( + result_stream, "sig is connected to (size=2): bar(12) foo(12) "); + + sigc::scoped_connection dst; + dst = std::move(*src); + src.reset(); // This will NOT disconnect from foo() + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(13); + util->check_result( + result_stream, "sig is connected to (size=2): bar(13) foo(13) "); + } + + // dst from above is now destroyed + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(14); + util->check_result( + result_stream, "sig is connected to (size=1): bar(14) "); + + // swap + sigc::scoped_connection sconfoo = sig.connect(&foo); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(15); + util->check_result( + result_stream, "sig is connected to (size=2): bar(15) foo(15) "); + sigc::scoped_connection sconbar = sig.connect(&bar); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(16); + util->check_result( + result_stream, "sig is connected to (size=3): bar(16) foo(16) bar(16) "); + swap(sconbar, sconfoo); + // disconnect sconbar, which was swapped to refer to &foo + sconbar.disconnect(); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(17); + util->check_result( + result_stream, "sig is connected to (size=2): bar(17) bar(17) "); + + // manual disconnection + sconfoo.disconnect(); // was swapped to refer to 2nd &bar + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(18); + util->check_result( + result_stream, "sig is connected to (size=1): bar(18) "); + + // release + sconfoo = sig.connect(&foo); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(19); + util->check_result( + result_stream, "sig is connected to (size=2): bar(19) foo(19) "); + sigc::connection rconfoo = sconfoo.release(); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(20); + util->check_result( + result_stream, "sig is connected to (size=2): bar(20) foo(20) "); + rconfoo.disconnect(); + result_stream << "sig is connected to (size=" << sig.size() << "): "; + sig(21); + util->check_result( + result_stream, "sig is connected to (size=1): bar(21) "); + + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/test_signal.cc b/tests/test_signal.cc index 163eb113..a7650dd8 100644 --- a/tests/test_signal.cc +++ b/tests/test_signal.cc @@ -1,32 +1,25 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include -#include -#include -#include +#include namespace { + +TestUtilities* util = nullptr; std::ostringstream result_stream; -int foo(int i) +int +foo(int i) { result_stream << "foo(int " << i << ") "; return 1; } -int bar(float i) -{ - result_stream << "bar(float " << i << ") "; - return 1; -} - struct A : public sigc::trackable { int foo(int i) @@ -42,53 +35,148 @@ struct A : public sigc::trackable } }; -} // end anonymous namespace - -int main(int argc, char* argv[]) +void +test_empty_signal() { - auto util = TestUtilities::get_instance(); - - if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - // signal - sigc::signal sig; + sigc::signal sig; // emit empty signal sig(0); util->check_result(result_stream, ""); +} + +void +test_simple() +{ + sigc::signal sig; + sig.connect([](int i) { return foo(i); }); + + sig(1); + util->check_result(result_stream, "foo(int 1) "); +} + +int +bar(float i) +{ + result_stream << "bar(float " << i << ") "; + return 1; +} + +template +void +test_auto_disconnection() +{ + // signal + T_signal sig; // connect some slots before emitting & test auto-disconnection { A a; - sig.connect(sigc::ptr_fun1(&foo)); - sig.connect(sigc::mem_fun1(&a, &A::foo)); - sig.connect(sigc::ptr_fun1(&bar)); + sig.connect(sigc::ptr_fun(&foo)); + sig.connect_first(sigc::mem_fun(a, &A::foo)); + sig.connect_first(sigc::ptr_fun(&bar)); sig(1); result_stream << sig.size(); - util->check_result(result_stream, "foo(int 1) A::foo(int 1) bar(float 1) 3"); + util->check_result(result_stream, "bar(float 1) A::foo(int 1) foo(int 1) 3"); } // a dies => auto-disconnect sig(2); result_stream << sig.size(); - util->check_result(result_stream, "foo(int 2) bar(float 2) 2"); + util->check_result(result_stream, "bar(float 2) foo(int 2) 2"); +} +void +test_reference() +{ // test reference A a; std::string str("guest book"); - sigc::signal sigstr; - sigstr.connect(sigc::mem_fun(&a, &A::bar)); + sigc::signal sigstr; + sigstr.connect(sigc::mem_fun(a, &A::bar)); sigstr(str); result_stream << str; util->check_result(result_stream, "A::foo(string 'guest book') foo was here"); +} +void +test_make_slot() +{ // test make_slot() - sig.connect(sigc::ptr_fun1(&foo)); - sigc::signal sig2; + sigc::signal sig; + sig.connect(sigc::ptr_fun(&foo)); + sig.connect_first([](float i) { return bar(i); }); + sig.connect(sigc::ptr_fun(&foo)); + sigc::signal sig2; sig2.connect(sig.make_slot()); sig2(3); - util->check_result(result_stream, "foo(int 3) bar(float 3) foo(int 3) "); + util->check_result(result_stream, "bar(float 3) foo(int 3) foo(int 3) "); + + // Delete a trackable_signal that has been connected to sig2. + sig2.clear(); + sig2.connect(sigc::ptr_fun(&bar)); + auto sig3 = std::make_unique>(); + sig3->connect(sigc::ptr_fun(&foo)); + sig2.connect(sig3->make_slot()); + sig2(2); + sig3.reset(); + sig2(42); + util->check_result(result_stream, "bar(float 2) foo(int 2) bar(float 42) "); +} + +void +test_clear_called_in_signal_handler() +{ + sigc::signal sig; + sig.connect([]() { result_stream << ", slot 1, "; }); + sig.connect( + [&sig]() + { + sig.clear(); + result_stream << "slot 2, "; + }); + sig.connect([]() { result_stream << "slot 3, "; }); + result_stream << sig.size(); + sig.emit(); + result_stream << sig.size(); + sig.emit(); + util->check_result(result_stream, "3, slot 1, slot 2, 0"); +} + +void +test_clear_called_outside_signal_handler() +{ + sigc::signal sig; + sig.connect([]() { result_stream << ", slot 1, "; }); + sig.connect([]() { result_stream << "slot 2, "; }); + sig.connect([]() { result_stream << "slot 3, "; }); + result_stream << sig.size(); + sig.emit(); + sig.clear(); + result_stream << sig.size(); + sig.emit(); + util->check_result(result_stream, "3, slot 1, slot 2, slot 3, 0"); +} + +} // end anonymous namespace + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_empty_signal(); + test_simple(); + test_auto_disconnection>(); + test_auto_disconnection>(); + test_reference(); + test_make_slot(); + test_clear_called_in_signal_handler(); + test_clear_called_outside_signal_handler(); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_signal_connect.cc b/tests/test_signal_connect.cc new file mode 100644 index 00000000..ef4e1045 --- /dev/null +++ b/tests/test_signal_connect.cc @@ -0,0 +1,121 @@ +/* Copyright 2024, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + +#include "testutilities.h" +#include +#include + +namespace +{ + +TestUtilities* util = nullptr; +std::ostringstream result_stream; + +void +fun(int i) +{ + result_stream << "fun(int " << i << ")"; +} + +[[maybe_unused]] +void +fun(double d) +{ + result_stream << "fun(double " << d << ")"; +} + +struct foo : public sigc::trackable +{ + void fun_nonconst(int i) + { + result_stream << "foo::fun_nonconst(int " << i << ")"; + } + + void fun_nonconst(double d) + { + result_stream << "foo::fun_nonconst(double " << d << ")"; + } + + void fun_const(int i) const + { + result_stream << "foo::fun_const(int " << i << ")"; + } + + void fun_const(double d) const + { + result_stream << "foo::fun_const(double " << d << ")"; + } +}; + +void +test_signal_connect_fun() +{ + sigc::signal signal; + + sigc::signal_connect(signal, &fun); + + signal.emit(42); + util->check_result(result_stream, "fun(int 42)"); +} + +void +test_signal_connect_method_nonconst() +{ + sigc::signal signal; + foo f; + + sigc::signal_connect(signal, f, &foo::fun_nonconst); + + signal.emit(42); + util->check_result(result_stream, "foo::fun_nonconst(int 42)"); +} + +void +test_signal_connect_method_const() +{ + sigc::signal signal; + foo f; + + sigc::signal_connect(signal, f, &foo::fun_const); + + signal.emit(42); + util->check_result(result_stream, "foo::fun_const(int 42)"); +} + +void +test_signal_connect_method_const_with_const_object() +{ + sigc::signal signal; + const foo f; + + sigc::signal_connect(signal, f, &foo::fun_const); + + signal.emit(42); + util->check_result(result_stream, "foo::fun_const(int 42)"); +} + +void +test_signal_connect_method() +{ + test_signal_connect_method_nonconst(); + test_signal_connect_method_const(); + test_signal_connect_method_const_with_const_object(); +} + +} // end anonymous namespace + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_signal_connect_fun(); + + test_signal_connect_method(); + + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/test_signal_move.cc b/tests/test_signal_move.cc index 6365e5bd..83a6316d 100644 --- a/tests/test_signal_move.cc +++ b/tests/test_signal_move.cc @@ -1,20 +1,17 @@ -/* Copyright 2015, The libsigc++ Development Team +/* Copyright 2015 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include -#include -#include -#include namespace { std::ostringstream result_stream; -int foo(int i) +int +foo(int i) { result_stream << "foo(int " << i << ")"; return 1; @@ -22,7 +19,8 @@ int foo(int i) } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -30,21 +28,21 @@ int main(int argc, char* argv[]) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; // signal - sigc::signal sig; + sigc::signal sig; sig.connect(sigc::ptr_fun(&foo)); sig(1); util->check_result(result_stream, "foo(int 1)"); - //Test the move constructor: - sigc::signal sig2(std::move(sig)); - sig(-2); + // Test the move constructor: + sigc::signal sig2(std::move(sig)); + sig(-2); // Test that the moved-from slot does nothing. sig2(2); util->check_result(result_stream, "foo(int 2)"); - //Test the move assignment operator: - sigc::signal sig3; + // Test the move assignment operator: + sigc::signal sig3; sig3 = std::move(sig2); - sig2(-3); + sig2(-3); // Test that the moved-from slot does nothing. sig3(3); util->check_result(result_stream, "foo(int 3)"); diff --git a/tests/test_size.cc b/tests/test_size.cc index c9024621..4b09a253 100644 --- a/tests/test_size.cc +++ b/tests/test_size.cc @@ -1,12 +1,10 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include #include -#include // The correct result of this test may be implementation-dependent. // No attempt is made to decide if the result is correct. @@ -17,11 +15,12 @@ namespace { struct A { - void foo(); + void foo() {} }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -32,19 +31,46 @@ int main(int argc, char* argv[]) { std::cout << "sizes of public classes:" << std::endl; + // libsigc++ 2.10: 8 + // libsigc++ 3.0: 8 std::cout << " trackable: " << sizeof(sigc::trackable) << std::endl; - std::cout << " slot: " << sizeof(sigc::slot) << std::endl; - std::cout << " signal: " << sizeof(sigc::signal) << std::endl; - std::cout << " signal::iterator: " << sizeof(sigc::signal::iterator) << std::endl; + + // libsigc++ 2.10: 16 + // libsigc++ 3.0: 16 + std::cout << " slot: " << sizeof(sigc::slot) << std::endl; + + // libsigc++ 2.10: 16 + // libsigc++ 3.0: 16 + std::cout << " signal: " << sizeof(sigc::signal) << std::endl; + + // libsigc++ 2.10: 8 + // libsigc++ 3.0: 8 std::cout << " connection: " << sizeof(sigc::connection) << std::endl; std::cout << std::endl << "sizes of internal classes:" << std::endl; - std::cout << " trackable_callback: " << sizeof(sigc::internal::trackable_callback) << std::endl; - std::cout << " trackable_callback_list: " << sizeof(sigc::internal::trackable_callback_list) << std::endl; + // libsigc++ 2.10: 16 + // libsigc++ 3.0: 16 + std::cout << " trackable_callback: " << sizeof(sigc::internal::trackable_callback) + << std::endl; + + // libsigc++ 2.10: 32 + // libsigc++ 3.0: 32 + std::cout << " trackable_callback_list: " << sizeof(sigc::internal::trackable_callback_list) + << std::endl; + + // libsigc++ 2.10: 48 + // libsigc++ 3.0: 48 std::cout << " slot_rep: " << sizeof(sigc::internal::slot_rep) << std::endl; - std::cout << " typed_slot_rep >: " - << sizeof(sigc::internal::typed_slot_rep >) << std::endl; + + // libsigc++ 2.10: 72 + // libsigc++ 3.0: 64 + std::cout << " typed_slot_rep >: " + << sizeof(sigc::internal::typed_slot_rep>) + << std::endl; + + // libsigc++ 2.10: 32 + // libsigc++ 3.0: 32 std::cout << " signal_impl: " << sizeof(sigc::internal::signal_impl) << std::endl; } return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; diff --git a/tests/test_slot.cc b/tests/test_slot.cc index 07b35806..7fd68bd8 100644 --- a/tests/test_slot.cc +++ b/tests/test_slot.cc @@ -1,84 +1,105 @@ -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include -#include -//The Tru64 compiler seems to need this to avoid an unresolved symbol -//See bug #161503 -#include +// The Tru64 compiler seems to need this to avoid an unresolved symbol +// See bug #161503 namespace { + +TestUtilities* util = nullptr; std::ostringstream result_stream; class foo { public: - void operator()(int i) - { - result_stream << "foo(int " << i << ")"; - } + void operator()(int i) { result_stream << "foo(int " << i << ")"; } void operator()(std::string& str) { result_stream << "foo(string '" << str << "') "; - str="foo was here"; + str = "foo was here"; } - void operator()(int, int) - { - result_stream << "foo(int, int)"; - } + void operator()(int, int) { result_stream << "foo(int, int)"; } }; -} // end anonymous namespace - -int main(int argc, char* argv[]) +void +test_simple() { - auto util = TestUtilities::get_instance(); - - if (!util->check_command_args(argc, argv)) - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - // simple test - sigc::slot s1 = foo(); + sigc::slot s1 = foo(); s1(1); util->check_result(result_stream, "foo(int 1)"); s1 = foo(); s1(2); util->check_result(result_stream, "foo(int 2)"); +} +void +test_implicit_conversion() +{ // test implicit conversion - sigc::slot s2 = foo(); + sigc::slot s2 = foo(); s2(3); util->check_result(result_stream, "foo(int 3)"); +} +void +test_reference() +{ // test reference - sigc::slot sl1 = foo(); + sigc::slot sl1 = foo(); std::string str("guest book"); sl1(str); result_stream << str; util->check_result(result_stream, "foo(string 'guest book') foo was here"); +} +void +test_operator_equals() +{ // test operator= - str = "guest book"; - sigc::slot sl2; + std::string str = "guest book"; + sigc::slot sl1 = foo(); + sigc::slot sl2; sl2 = sl1; sl1 = sl2; sl1(str); result_stream << str; util->check_result(result_stream, "foo(string 'guest book') foo was here"); +} +void +test_copy_ctor() +{ // test copy ctor - sigc::slot s1_clone(s1); + sigc::slot s1 = foo(); + sigc::slot s1_clone(s1); s1_clone(4); util->check_result(result_stream, "foo(int 4)"); +} + +} // end anonymous namespace + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_simple(); + test_implicit_conversion(); + test_reference(); + test_operator_equals(); + test_copy_ctor(); return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_slot_disconnect.cc b/tests/test_slot_disconnect.cc index 4044135d..e14cf99e 100644 --- a/tests/test_slot_disconnect.cc +++ b/tests/test_slot_disconnect.cc @@ -1,38 +1,38 @@ -/* Copyright 2005, The libsigc++ Development Team +/* Copyright 2005 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include -#include namespace { std::ostringstream result_stream; -void Foo() +void +Foo() { result_stream << "Foo"; } -void Bar() +void +Bar() { result_stream << "Bar"; } } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - //Note that sigc::ptr_fun() creates a sigc::pointer_functor0. - sigc::slot theSlot(sigc::ptr_fun(&Foo)); + // Note that sigc::ptr_fun() creates a sig::pointer_functor. + sigc::slot theSlot(sigc::ptr_fun(&Foo)); theSlot(); util->check_result(result_stream, "Foo"); @@ -44,7 +44,7 @@ int main(int argc, char* argv[]) theSlot(); util->check_result(result_stream, "Bar"); - theSlot = sigc::slot(); // Assign an empty slot. + theSlot = sigc::slot(); // Assign an empty slot. theSlot(); util->check_result(result_stream, ""); diff --git a/tests/test_slot_move.cc b/tests/test_slot_move.cc index 06975f51..d207172c 100644 --- a/tests/test_slot_move.cc +++ b/tests/test_slot_move.cc @@ -1,16 +1,12 @@ -/* Copyright 2015, The libsigc++ Development Team +/* Copyright 2015 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" #include -#include -#include -#include -//The Tru64 compiler seems to need this to avoid an unresolved symbol -//See bug #161503 -#include +// The Tru64 compiler seems to need this to avoid an unresolved symbol +// See bug #161503 namespace { @@ -19,26 +15,21 @@ std::ostringstream result_stream; class foo { public: - void operator()(int i) - { - result_stream << "foo(int " << i << ")"; - } + void operator()(int i) { result_stream << "foo(int " << i << ")"; } void operator()(std::string& str) { result_stream << "foo(string '" << str << "') "; - str="foo was here"; + str = "foo was here"; } - void operator()(int, int) - { - result_stream << "foo(int, int)"; - } + void operator()(int, int) { result_stream << "foo(int, int)"; } }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); @@ -46,20 +37,20 @@ int main(int argc, char* argv[]) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; // simple test - sigc::slot s1 = foo(); + sigc::slot s1 = foo(); s1(1); util->check_result(result_stream, "foo(int 1)"); // test move constructor: - sigc::slot s2(std::move(s1)); - s1(-2); + sigc::slot s2(std::move(s1)); + s1(-2); // Test that the moved-from slot does nothing. s2(2); util->check_result(result_stream, "foo(int 2)"); // test move assignment: - sigc::slot s3; + sigc::slot s3; s3 = std::move(s2); - s2(-3); + s2(-3); // Test that the moved-from slot does nothing. s3(3); util->check_result(result_stream, "foo(int 3)"); diff --git a/tests/test_track_obj.cc b/tests/test_track_obj.cc index a6ce6edf..5d919534 100644 --- a/tests/test_track_obj.cc +++ b/tests/test_track_obj.cc @@ -1,4 +1,4 @@ -/* Copyright (C) 2013 The libsigc++ Development Team +/* Copyright (C) 2013 - 2016, The libsigc++ Development Team * * This file is part of libsigc++. * @@ -17,32 +17,28 @@ */ // The purpose of this test case is threefold. -// - Test sigc::track_obj(). +// - Test sigc::track_obj() and sigc::track_object(). // - Show that a slot with a C++11 lambda expression can be automatically // disconnected when an object derived from sigc::trackable is deleted, -// provided sigc::track_obj() is used. -// It's shown here as a preparation for deprecating and eventually -// deleting the libsigc++ lambda expressions. +// provided sigc::track_obj() or sigc::track_object() is used. +// It shows that C++11 lambda expressions can replace the libsigc++ lambda +// expressions, which have been removed. // See https://bugzilla.gnome.org/show_bug.cgi?id=672555 // - Test the code example in the documentation in sigc++/adaptors/track_obj.h. // -// To test the C++11 lambda expressions with gcc 4.6.3 (and probably some later -// versions of gcc; gcc 4.7.x also understands -std=c++11): -// make CXXFLAGS='-g -O2 -std=c++0x' test_track_obj -// ./test_track_obj -// echo $? // If test_track_obj writes nothing and the return code is 0, the test has passed. +// sigc::track_obj() is deprecated, but let's keep the test if possible. +// If libsigc++ is configured with -Dbuild-deprecated-api=false +// (--disable-deprecated-api), SIGCXX_DISABLE_DEPRECATED is defined in +// sigc++config.h. An undef at the start of this file has no effect. +#undef SIGCXX_DISABLE_DEPRECATED #include "testutilities.h" -#include #include -#include -#include #include #include - namespace { std::ostringstream result_stream; @@ -50,8 +46,8 @@ std::ostringstream result_stream; struct book : public sigc::trackable { explicit book(const std::string& name) : name_(name) {} - operator std::string& () { return name_; } - operator const std::string& () const { return name_; } + operator std::string&() { return name_; } + operator const std::string&() const { return name_; } std::string name_; }; @@ -59,156 +55,190 @@ struct bar_group4 : public sigc::trackable { }; -class Functor1 : public sigc::functor_base +class Functor1 { public: - typedef std::string result_type; + explicit Functor1(const bar_group4& bar) : bar_(bar) {} - Functor1(const bar_group4& bar) - : bar_(bar) {} + std::string operator()(int i) { return (i < 0) ? "negative" : ((i > 0) ? "positive" : "zero"); } - std::string operator()(int i) - { - return (i<0) ? "negative" : ((i>0) ? "positive" : "zero"); - } - -private: +protected: + // Don't make it private. clang++ does not like unused private data. const bar_group4& bar_; }; -class Functor2 : public sigc::functor_base +class Functor2 { public: - typedef std::string result_type; - - Functor2(const bar_group4& bar, const book& aBook) - : bar_(bar), aBook_(aBook) {} + Functor2(const bar_group4& bar, const book& aBook) : bar_(bar), aBook_(aBook) {} std::string operator()(int i, const std::string& str) const { - std::string result = (i<0) ? "negative, " : ((i>0) ? "positive, " : "zero, "); + std::string result = (i < 0) ? "negative, " : ((i > 0) ? "positive, " : "zero, "); result += str; result += aBook_; return result; } -private: +protected: + // Don't make it private. clang++ does not like unused private data. const bar_group4& bar_; + +private: const book& aBook_; }; -//C++11 lamba expressions: +// C++11 lamba expressions: -inline std::ostringstream& operator << (std::ostringstream& s, const book& b) +inline std::ostringstream& +operator<<(std::ostringstream& s, const book& b) { s << b.name_; return s; } -void egon(std::string& str) +void +egon(std::string& str) { result_stream << "egon(string '" << str << "')"; str = "egon was here"; } -void foo_group4(bar_group4&) +void +foo_group4(bar_group4&) { result_stream << "foo_group4(bar_group4&)"; } } // end anonymous namespace - -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - sigc::slot sl1; + sigc::slot sl1; + sigc::slot sl2; { bar_group4 bar4; +#ifndef SIGCXX_DISABLE_DEPRECATED sl1 = sigc::track_obj(Functor1(bar4), bar4); - result_stream << sl1(-2); - util->check_result(result_stream, "negative"); +#else + sl1 = sigc::track_object(Functor1(bar4), bar4); +#endif + sl2 = sigc::track_object(Functor1(bar4), bar4); + result_stream << sl1(-2) << ", " << sl2(2); + util->check_result(result_stream, "negative, positive"); - } // auto-disconnect sl1 + } // auto-disconnect sl1 and sl2 - result_stream << sl1(-2); - util->check_result(result_stream, ""); + result_stream << sl1(-2) << ", " << sl2(2); + util->check_result(result_stream, ", "); // Allocate on the heap. valgrind can then find erroneous memory accesses. // (There should be none, of course.) - auto psl2 = new sigc::slot; - bar_group4* pbar4 = new bar_group4; - book* pbook4 = new book("A Book"); - *psl2 = sigc::track_obj(Functor2(*pbar4, *pbook4), *pbar4, *pbook4); - result_stream << (*psl2)(0, "Book title: "); - util->check_result(result_stream, "zero, Book title: A Book"); - - delete pbook4; // auto-disconnect *psl2 + auto psl3 = new sigc::slot; + auto psl4 = new sigc::slot; + auto pbar4 = new bar_group4; + auto pbook4 = new book("A Book"); +#ifndef SIGCXX_DISABLE_DEPRECATED + *psl3 = sigc::track_obj(Functor2(*pbar4, *pbook4), *pbar4, *pbook4); +#else + *psl3 = sigc::track_object(Functor2(*pbar4, *pbook4), *pbar4, *pbook4); +#endif + *psl4 = sigc::track_object(Functor2(*pbar4, *pbook4), *pbar4, *pbook4); + result_stream << (*psl3)(0, "Book title: ") << ", " << (*psl4)(1, "Title: "); + util->check_result(result_stream, "zero, Book title: A Book, positive, Title: A Book"); + + delete pbook4; // auto-disconnect *psl3 and *psl4 pbook4 = nullptr; - result_stream << (*psl2)(0, "Book title: "); - util->check_result(result_stream, ""); - delete psl2; - psl2 = nullptr; + result_stream << (*psl3)(0, "Book title: ") << ", " << (*psl4)(1, "Title: "); + util->check_result(result_stream, ", "); + delete psl3; + psl3 = nullptr; + delete psl4; + psl4 = nullptr; delete pbar4; pbar4 = nullptr; - -//C++11 lambda expressions: + // C++11 lambda expressions: // auto-disconnect // If you want to auto-disconnect a slot with a C++11 lambda expression // that contains references to sigc::trackable-derived objects, you must use - // sigc::track_obj(). - sigc::slot sl10; + // sigc::track_obj() or sigc::track_object(). + sigc::slot sl11; + sigc::slot sl12; { book guest_book("karl"); - // sl1 = [&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }; // no auto-disconnect - sl10 = sigc::track_obj([&guest_book](std::ostringstream& stream){ stream << guest_book; }, guest_book); - sl10(result_stream); - util->check_result(result_stream, "karl"); - - } // auto-disconnect sl10 - - sl10(result_stream); + // no auto-disconnect + // sl1 = [&guest_book](std::ostringstream& stream){ stream << guest_book << "\n"; }; +#ifndef SIGCXX_DISABLE_DEPRECATED + sl11 = sigc::track_obj( + [&guest_book](std::ostringstream& stream) { stream << guest_book; }, guest_book); +#else + sl11 = sigc::track_object( + [&guest_book](std::ostringstream& stream) { stream << guest_book; }, guest_book); +#endif + sl12 = sigc::track_object( + [&guest_book](std::ostringstream& stream) { stream << guest_book; }, guest_book); + sl11(result_stream); + sl12(result_stream); + util->check_result(result_stream, "karlkarl"); + + } // auto-disconnect sl11 and sl12 + + sl11(result_stream); + sl12(result_stream); util->check_result(result_stream, ""); // auto-disconnect - sigc::slot sl20; + sigc::slot sl21; + sigc::slot sl22; { book guest_book("karl"); // sl2 = [&guest_book] () { egon(guest_book); }; // no auto-disconnect // sl2 = std::bind(&egon, std::ref(guest_book)); // does not compile (gcc 4.6.3) - sl20 = sigc::track_obj([&guest_book] () { egon(guest_book); }, guest_book); - sl20(); - util->check_result(result_stream, "egon(string 'karl')"); +#ifndef SIGCXX_DISABLE_DEPRECATED + sl21 = sigc::track_obj([&guest_book]() { egon(guest_book); }, guest_book); +#else + sl21 = sigc::track_object([&guest_book]() { egon(guest_book); }, guest_book); +#endif + sl22 = sigc::track_object([&guest_book]() { egon(guest_book); }, guest_book); + sl21(); + sl22(); + util->check_result(result_stream, "egon(string 'karl')egon(string 'egon was here')"); result_stream << static_cast(guest_book); util->check_result(result_stream, "egon was here"); - } // auto-disconnect sl20 + } // auto-disconnect sl21 and sl22 - sl20(); + sl21(); + sl22(); util->check_result(result_stream, ""); - - // Code example in the documentation sigc++/adaptors/macros/track_obj.h.m4 - // ----------------------------------------------------------------------- + // Code example in the documentation sigc++/adaptors/track_obj.h. + // -------------------------------------------------------------- { - //struct bar : public sigc::trackable {} some_bar; - sigc::signal some_signal; + // struct bar : public sigc::trackable {} some_bar; + sigc::signal some_signal; { bar_group4 some_bar; - //some_signal.connect(sigc::group(&foo,sigc::ref(some_bar))); - // disconnected automatically if some_bar goes out of scope - //some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect - //some_signal.connect(sigc::bind(&foo_group4, sigc::ref(some_bar))); // auto-disconnects, but we prefer C++11 lambda - some_signal.connect(sigc::track_obj([&some_bar](){ foo_group4(some_bar); }, some_bar)); + // some_signal.connect([&some_bar](){ foo_group4(some_bar); }); // no auto-disconnect + // some_signal.connect(sigc::bind(&foo_group4, std::ref(some_bar))); // auto-disconnects, + // but we prefer C++11 lambda +#ifndef SIGCXX_DISABLE_DEPRECATED + some_signal.connect(sigc::track_obj([&some_bar]() { foo_group4(some_bar); }, some_bar)); +#else + some_signal.connect(sigc::track_object([&some_bar]() { foo_group4(some_bar); }, some_bar)); +#endif + some_signal.connect(sigc::track_object([&some_bar]() { foo_group4(some_bar); }, some_bar)); some_signal.emit(); - util->check_result(result_stream, "foo_group4(bar_group4&)"); + util->check_result(result_stream, "foo_group4(bar_group4&)foo_group4(bar_group4&)"); } // auto-disconnect the lambda expression @@ -216,6 +246,5 @@ int main(int argc, char* argv[]) util->check_result(result_stream, ""); } - return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; } diff --git a/tests/test_trackable.cc b/tests/test_trackable.cc index 159aeeb2..bd48fe61 100644 --- a/tests/test_trackable.cc +++ b/tests/test_trackable.cc @@ -1,44 +1,38 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" -#include -#include #include #include -#include namespace { std::ostringstream result_stream; -class my_class: public sigc::trackable +class my_class : public sigc::trackable { public: - int i; + int i = 0; - void foo() - { - result_stream << i; - } + void foo() { result_stream << i; } }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - sigc::slot sl; + sigc::slot sl; { my_class t; t.i = 10; - sl = sigc::mem_fun0(&t, &my_class::foo); + sl = sigc::mem_fun(t, &my_class::foo); sl(); util->check_result(result_stream, "10"); } diff --git a/tests/test_trackable_move.cc b/tests/test_trackable_move.cc index 2d16273e..05a14b42 100644 --- a/tests/test_trackable_move.cc +++ b/tests/test_trackable_move.cc @@ -1,76 +1,65 @@ -// -*- c++ -*- -/* Copyright 2002, The libsigc++ Development Team +/* Copyright 2002 - 2016, The libsigc++ Development Team * Assigned to public domain. Use as you wish without restriction. */ #include "testutilities.h" -#include -#include #include #include -#include namespace { std::ostringstream result_stream; -class my_class: public sigc::trackable +class my_class : public sigc::trackable { public: - - my_class() - : i(0) - {} + my_class() : i(0) {} my_class(const my_class& src) = delete; my_class& operator=(const my_class& src) = delete; - my_class(my_class&& src) - : sigc::trackable(std::move(src)), - i(std::move(src.i)) + my_class(my_class&& src) noexcept : sigc::trackable(std::move(src)), i(std::move(src.i)) { src.i = 0; } - my_class& operator=(my_class&& src) + my_class& operator=(my_class&& src) noexcept { sigc::trackable::operator=(std::move(src)); i = std::move(src.i); - src.i = 0; + src.i = 0; // Make the moved-from object zeroed. Undefined behaviour would be acceptable too. return *this; } - void foo() - { - result_stream << i; - } + void foo() { result_stream << i; } int i; }; } // end anonymous namespace -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - sigc::slot sl; + sigc::slot sl; { my_class t; t.i = 10; - sl = sigc::mem_fun0(&t, &my_class::foo); + sl = sigc::mem_fun(t, &my_class::foo); sl(); util->check_result(result_stream, "10"); - //Create another trackable via a move: + // Create another trackable via a move: my_class t2(std::move(t)); t2.i = 15; result_stream.clear(); - sl = sigc::mem_fun0(&t2, &my_class::foo); + sl = sigc::mem_fun(t2, &my_class::foo); sl(); util->check_result(result_stream, "15"); diff --git a/tests/test_tuple_cdr.cc b/tests/test_tuple_cdr.cc new file mode 100644 index 00000000..da977626 --- /dev/null +++ b/tests/test_tuple_cdr.cc @@ -0,0 +1,92 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see +#include +#include +#include +#include + +void +test_tuple_type_cdr() +{ + using type_tuple_isd = std::tuple; + using type_tuple_sd = std::tuple; + using type_tuple_suffix = sigc::internal::tuple_type_cdr::type; + + static_assert( + std::tuple_size::value == 2, "unexpected tuple_cdr()ed tuple size."); + static_assert( + std::is_same::value, "unexpected tuple_cdr()ed tuple type"); +} + +void +test_tuple_cdr() +{ + auto t_larger = std::make_tuple(nullptr, std::string("hello"), std::string("world")); + auto t_suffix = sigc::internal::tuple_cdr(t_larger); + assert(std::get<0>(t_suffix) == "hello"); + assert(std::get<1>(t_suffix) == "world"); + + using type_tuple_suffix = std::tuple; + + static_assert(std::tuple_size::value == 2, "unexpected cdr()ed tuple size."); + static_assert( + std::is_same::value, "unexpected cdr()ed tuple type"); +} + +void +test_tuple_cdr_stdref() +{ + std::string b = "yadda"; + std::string c = "yaddayadda"; + auto t_larger = std::make_tuple(1, std::ref(b), std::ref(c)); + + // std::cout << "debug: " << type(std::get<1>(t_larger)) << std::endl; + + auto t_suffix = sigc::internal::tuple_cdr(t_larger); + b = "hello"; + c = "world"; + // This works, but it's not what we are testing here: + // assert(std::get<1>(t_larger) == "hello"); + + assert(std::get<0>(t_suffix) == "hello"); + assert(std::get<1>(t_suffix) == "world"); +} + +constexpr void +test_tuple_cdr_constexpr() +{ + constexpr auto str_hello = "hello"; + constexpr auto str_world = "world"; + + constexpr auto t_larger = std::make_tuple(nullptr, str_hello, str_world); + constexpr auto t_suffix = sigc::internal::tuple_cdr(t_larger); + assert(std::get<0>(t_suffix) == str_hello); + assert(std::get<1>(t_suffix) == str_world); +} + +int +main() +{ + test_tuple_type_cdr(); + test_tuple_cdr(); + test_tuple_cdr_stdref(); + + test_tuple_cdr_constexpr(); + + return EXIT_SUCCESS; +} diff --git a/tests/test_tuple_end.cc b/tests/test_tuple_end.cc new file mode 100644 index 00000000..4b8de242 --- /dev/null +++ b/tests/test_tuple_end.cc @@ -0,0 +1,113 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see +#include +#include +#include +#include + +void +test_tuple_end() +{ + { + auto t_original = std::make_tuple(nullptr, std::string("hello"), std::string("world")); + auto t_suffix = sigc::internal::tuple_end<3>(t_original); + + static_assert( + std::tuple_size::value == 3, "unexpected tuple_end()ed tuple size."); + + assert(std::get<0>(t_suffix) == nullptr); + assert(std::get<1>(t_suffix) == "hello"); + assert(std::get<2>(t_suffix) == "world"); + + static_assert(std::is_same::value, + "unexpected end()ed tuple type"); + } + + { + auto t_original = std::make_tuple(nullptr, std::string("hello"), std::string("world")); + auto t_suffix = sigc::internal::tuple_end<2>(t_original); + + static_assert( + std::tuple_size::value == 2, "unexpected tuple_end()ed tuple size."); + + assert(std::get<0>(t_suffix) == "hello"); + assert(std::get<1>(t_suffix) == "world"); + + using type_tuple_suffix = std::tuple; + static_assert( + std::is_same::value, "unexpected end()ed tuple type"); + } + + { + auto t_original = std::make_tuple(nullptr, std::string("hello"), std::string("world")); + auto t_suffix = sigc::internal::tuple_end<1>(t_original); + + static_assert( + std::tuple_size::value == 1, "unexpected tuple_end()ed tuple size."); + + assert(std::get<0>(t_suffix) == "world"); + + using type_tuple_suffix = std::tuple; + static_assert( + std::is_same::value, "unexpected end()ed tuple type"); + } +} + +void +test_tuple_end_stdref() +{ + std::string c = "yadda"; + std::string d = "yaddayadda"; + auto t_larger = std::make_tuple(1, 2, std::ref(c), std::ref(d)); + + auto t_suffix = sigc::internal::tuple_end<2>(t_larger); + c = "hello"; + d = "world"; + // This works, but it's not what we are testing here: + // assert(std::get<0>(t_larger) == "hello"); + + assert(std::get<0>(t_suffix) == "hello"); + assert(std::get<1>(t_suffix) == "world"); +} + +constexpr void +test_tuple_end_constexpr() +{ + constexpr auto str_hello = "hello"; + constexpr auto str_world = "world"; + + constexpr auto t_original = std::make_tuple(nullptr, str_hello, str_world); + constexpr auto t_suffix = sigc::internal::tuple_end<2>(t_original); + + static_assert( + std::tuple_size::value == 2, "unexpected tuple_end()ed tuple size."); + + assert(std::get<0>(t_suffix) == str_hello); + assert(std::get<1>(t_suffix) == str_world); +} + +int +main() +{ + test_tuple_end(); + test_tuple_end_stdref(); + + test_tuple_end_constexpr(); + + return EXIT_SUCCESS; +} diff --git a/tests/test_tuple_for_each.cc b/tests/test_tuple_for_each.cc new file mode 100644 index 00000000..003ecdc9 --- /dev/null +++ b/tests/test_tuple_for_each.cc @@ -0,0 +1,247 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see +#include +#include +#include +#include +#include + +template +class for_each_simple +{ +public: + static void visit(const T_element_from& from) + { + std::cout << "for_each_simple(): " << std::to_string(from) << std::endl; + } +}; + +void +test_tuple_for_each_same_types() +{ + { + auto t_original = std::make_tuple(1, 2, 3); + sigc::internal::tuple_for_each(t_original); + } + + { + auto t_original = std::make_tuple(1, static_cast(2.1f), 3); + sigc::internal::tuple_for_each(t_original); + } +} + +template +class for_each_simple_with_extras +{ +public: + static void visit(const T_element_from& from, int extra1, const std::string& extra2) + { + std::cout << "for_each_simple_with_extras(): from=" << std::to_string(from) + << ", extra1: " << extra1 << ", extra2: " << extra2 << std::endl; + } +}; + +void +test_tuple_for_each_same_types_with_extras() +{ + { + auto t_original = std::make_tuple(1, static_cast(2.1f), 3); + sigc::internal::tuple_for_each(t_original, 89, "eightynine"); + } +} + +template +class for_each_simple_with_nonconst_extras +{ +public: + static void visit(const T_element_from& from, int& extra) { extra += (int)from; } +}; + +void +test_tuple_for_each_same_types_with_nonconst_extras() +{ + { + auto t_original = std::make_tuple(1, static_cast(2.1f), 3); + int extra = 0; + + sigc::internal::tuple_for_each(t_original, extra); + // std::cout << "extra: " << extra << std::endl; + assert(extra == 6); + } +} + +// The general template declaration. +// We then provide specializations for each type, +// so we can test having a different return value for each T_element_from type. +template +class visitor_with_specializations; + +// An int will be converted to a std::string: +template<> +class visitor_with_specializations +{ +public: + static void visit(const int& from) + { + std::cout << "visitor_with_specializations::visit(): " << std::to_string(from) << std::endl; + } +}; + +// A double will be converted to a char: +template<> +class visitor_with_specializations +{ +public: + static void visit(const double& from) + { + std::cout << "visitor_with_specializations::visit(): " << std::to_string(from)[0] << std::endl; + } +}; + +// A std::string will be converted to an int: +template<> +class visitor_with_specializations +{ +public: + static void visit(const std::string& from) + { + std::cout << "visitor_with_specializations::visit(): " << std::stoi(from) << std::endl; + } +}; + +// A const char* will be converted to an int: +template<> +class visitor_with_specializations +{ +public: + static void visit(const char* from) + { + std::cout << "visitor_with_specializations::visit(): " << std::stoi(from) << std::endl; + } +}; + +void +test_tuple_for_each_multiple_types() +{ + auto t_original = std::make_tuple(1, static_cast(2.1f), std::string("3")); + sigc::internal::tuple_for_each(t_original); +} + +template +class for_each_nonconst +{ +public: + static void visit(T_element_from& from) + { + from *= 2; + // Or, for instance, call a non-const method on from. + } +}; + +void +test_tuple_for_each_nonconst() +{ + auto t = std::make_tuple(1, 2, 3); + sigc::internal::tuple_for_each(t); + std::cout << std::get<0>(t) << std::endl; + assert(std::get<0>(t) == 2); + assert(std::get<1>(t) == 4); + assert(std::get<2>(t) == 6); +} + +void +test_tuple_for_each_stdref() +{ + { + int a = 1; + int b = 2; + int c = 3; + auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c)); + sigc::internal::tuple_for_each(t_original); + } + + { + int a = 1; + int b = 2; + int c = 3; + auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c)); + sigc::internal::tuple_for_each(t_original); + assert(a == 2); + assert(b == 4); + assert(c == 6); + } +} + +static std::string correct_sequence_output; + +template +class for_each_correct_sequence +{ +public: + static void visit(const T_element_from& from) + { + // std::cout << "from: " << from << std::endl; + correct_sequence_output += std::to_string(from); + } +}; + +void +test_tuple_for_each_correct_sequence() +{ + correct_sequence_output.clear(); + auto t = std::make_tuple(1, 2, 3); + sigc::internal::tuple_for_each(t); + // std::cout << "correct_sequence_output: " << correct_sequence_output << std::endl; + assert(correct_sequence_output == "123"); +} + +void +test_tuple_for_each_empty_tuple() +{ + auto t = std::tuple<>(); + sigc::internal::tuple_for_each(t); +} + +constexpr void +test_tuple_for_each_constexpr() +{ + constexpr auto t_original = std::make_tuple(1, static_cast(2.1f), "3"); + sigc::internal::tuple_for_each(t_original); +} + +int +main() +{ + test_tuple_for_each_same_types(); + test_tuple_for_each_same_types_with_extras(); + test_tuple_for_each_same_types_with_nonconst_extras(); + + test_tuple_for_each_multiple_types(); + + test_tuple_for_each_nonconst(); + + test_tuple_for_each_stdref(); + + test_tuple_for_each_correct_sequence(); + + test_tuple_for_each_empty_tuple(); + + test_tuple_for_each_constexpr(); + + return EXIT_SUCCESS; +} diff --git a/tests/test_tuple_start.cc b/tests/test_tuple_start.cc new file mode 100644 index 00000000..0e73fcd1 --- /dev/null +++ b/tests/test_tuple_start.cc @@ -0,0 +1,143 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see +#include +#include +#include +#include + +void +test_tuple_type_start() +{ + { + using type_tuple = std::tuple; + using type_tuple_start = sigc::internal::tuple_type_start::type; + using type_tuple_expected = std::tuple; + + static_assert(std::is_same::value, + "unexpected type_tuple_start type"); + } + + { + using type_tuple = std::tuple; + using type_tuple_start = sigc::internal::tuple_type_start::type; + using type_tuple_expected = std::tuple; + + static_assert(std::is_same::value, + "unexpected type_tuple_start type"); + } + + { + using type_tuple = std::tuple; + using type_tuple_start = sigc::internal::tuple_type_start::type; + using type_tuple_expected = std::tuple; + + static_assert(std::is_same::value, + "unexpected type_tuple_start type"); + } +} + +void +test_tuple_start() +{ + { + auto t_original = std::make_tuple(nullptr, std::string("hello"), std::string("world")); + auto t_prefix = sigc::internal::tuple_start<3>(t_original); + + static_assert( + std::tuple_size::value == 3, "unexpected tuple_start()ed tuple size."); + + assert(std::get<0>(t_prefix) == nullptr); + assert(std::get<1>(t_prefix) == "hello"); + assert(std::get<2>(t_prefix) == "world"); + + static_assert(std::is_same::value, + "unexpected start()ed tuple type"); + } + + { + auto t_original = std::make_tuple(nullptr, std::string("hello"), std::string("world")); + auto t_prefix = sigc::internal::tuple_start<2>(t_original); + + static_assert( + std::tuple_size::value == 2, "unexpected tuple_start()ed tuple size."); + + assert(std::get<0>(t_prefix) == nullptr); + assert(std::get<1>(t_prefix) == "hello"); + + using type_tuple_prefix = std::tuple; + static_assert(std::is_same::value, + "unexpected start()ed tuple type"); + } + + { + auto t_original = std::make_tuple(nullptr, std::string("hello"), std::string("world")); + auto t_prefix = sigc::internal::tuple_start<1>(t_original); + + static_assert( + std::tuple_size::value == 1, "unexpected tuple_start()ed tuple size."); + + assert(std::get<0>(t_prefix) == nullptr); + + using type_tuple_prefix = std::tuple; + static_assert(std::is_same::value, + "unexpected start()ed tuple type"); + } +} + +void +test_tuple_start_stdref() +{ + std::string a = "yadda"; + std::string b = "yaddayadda"; + auto t_larger = std::make_tuple(std::ref(a), std::ref(b), 1); + + auto t_prefix = sigc::internal::tuple_start<2>(t_larger); + a = "hello"; + b = "world"; + // This works, but it's not what we are testing here: + // assert(std::get<0>(t_larger) == "hello"); + + assert(std::get<0>(t_prefix) == "hello"); + assert(std::get<1>(t_prefix) == "world"); +} + +constexpr void +test_tuple_start_constexpr() +{ + constexpr auto str_hello = "hello"; + constexpr auto str_world = "hello"; + + constexpr auto t_original = std::make_tuple(nullptr, str_hello, str_world); + constexpr auto t_prefix = sigc::internal::tuple_start<2>(t_original); + + static_assert( + std::tuple_size::value == 2, "unexpected tuple_start()ed tuple size."); + + assert(std::get<0>(t_prefix) == nullptr); + assert(std::get<1>(t_prefix) == str_hello); +} + +int +main() +{ + test_tuple_type_start(); + test_tuple_start(); + test_tuple_start_stdref(); + + test_tuple_start_constexpr(); +} diff --git a/tests/test_tuple_transform_each.cc b/tests/test_tuple_transform_each.cc new file mode 100644 index 00000000..c5a4b87d --- /dev/null +++ b/tests/test_tuple_transform_each.cc @@ -0,0 +1,311 @@ +/* Copyright (C) 2016 Murray Cumming + * + * This program 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 3 of the License, or + * (at your option) any later version. + * + * This program 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 this program. If not, see +#include +#include +#include +#include +#include + +template +class transform_to_string +{ +public: + static decltype(auto) transform(T_element_from& from) { return std::to_string(from); } +}; + +// In these tests, t_expected has elements all of the same type. +void +test_tuple_transform_each_same_types() +{ + { + auto t_original = std::make_tuple(1, 2, 3); + auto t_transformed = sigc::internal::tuple_transform_each(t_original); + auto t_expected = std::make_tuple(std::string("1"), std::string("2"), std::string("3")); + + static_assert(std::tuple_size::value == 3, + "unexpected tuple_transform_each()ed tuple size."); + + assert(std::get<0>(t_transformed) == "1"); + assert(std::get<1>(t_transformed) == "2"); + assert(std::get<2>(t_transformed) == "3"); + + static_assert(std::is_same::value, + "unexpected transform_each()ed tuple type"); + } + + { + auto t_original = std::make_tuple(1, static_cast(2.1f), 3); + auto t_transformed = sigc::internal::tuple_transform_each(t_original); + auto t_expected = std::make_tuple(std::string("1"), std::string("2"), std::string("3")); + + static_assert(std::tuple_size::value == 3, + "unexpected tuple_transform_each()ed tuple size."); + + assert(std::get<0>(t_transformed) == "1"); + assert(std::get<1>(t_transformed).substr(0, 3) == "2.1"); + assert(std::get<2>(t_transformed) == "3"); + + static_assert(std::is_same::value, + "unexpected transform_each()ed tuple type"); + } +} + +// The general template declaration. +// We then provide specializations for each type, +// so we can test having a different return value for each T_element_from type. +template +class transform_to_something; + +// An int will be converted to a std::string: +template<> +class transform_to_something +{ +public: + static std::string transform(int& from) { return std::to_string(from); } +}; + +// A double will be converted to a char: +template<> +class transform_to_something +{ +public: + static char transform(double& from) { return std::to_string(from)[0]; } +}; + +// A std::string will be converted to an int: +template<> +class transform_to_something +{ +public: + static int transform(std::string& from) { return std::stoi(from); } +}; + +// In these tests, t_expected has elements of different types. +void +test_tuple_transform_each_multiple_types() +{ + auto t_original = std::make_tuple(1, static_cast(2.1f), std::string("3")); + auto t_transformed = sigc::internal::tuple_transform_each(t_original); + auto t_expected = std::make_tuple(std::string("1"), '2', 3); + + static_assert(std::tuple_size::value == 3, + "unexpected tuple_transform_each()ed tuple size."); + + assert(std::get<0>(t_transformed) == "1"); + assert(std::get<1>(t_transformed) == '2'); + assert(std::get<2>(t_transformed) == 3); + + static_assert(std::is_same::value, + "unexpected transform_each()ed tuple type"); +} + +template +class transform_each_nonconst +{ +public: + static int transform(T_element_from& from) + { + from *= 2; + // Or, for instance, call a non-const method on from. + + return from * 10; + } +}; + +void +test_tuple_transform_each_nonconst() +{ + auto t = std::make_tuple(1, 2, 3); + auto t_transformed = sigc::internal::tuple_transform_each(t); + + // Check that t was changed (from * 2): + assert(std::get<0>(t) == 2); + assert(std::get<1>(t) == 4); + assert(std::get<2>(t) == 6); + + // Check that t_transformed has the expected values ( from * 2 * 10): + assert(std::get<0>(t_transformed) == 20); + assert(std::get<1>(t_transformed) == 40); + assert(std::get<2>(t_transformed) == 60); +} + +void +test_tuple_transform_each_stdref() +{ + int a = 1; + int b = 2; + int c = 3; + auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c)); + auto t_transformed = sigc::internal::tuple_transform_each(t_original); + auto t_expected = std::make_tuple(std::string("1"), std::string("2"), std::string("3")); + + static_assert(std::tuple_size::value == 3, + "unexpected tuple_transform_each()ed tuple size."); + + assert(std::get<0>(t_transformed) == "1"); + assert(std::get<1>(t_transformed) == "2"); + assert(std::get<2>(t_transformed) == "3"); + + static_assert(std::is_same::value, + "unexpected transform_each()ed tuple type"); +} + +// This can only be used via std::ref(), for instance. +// Any attempt to copy or move it, should cause a compiler error. +class NonCopyable +{ +public: + explicit NonCopyable(int val) : m_val(val) {} + + int get_val() const { return m_val; } + + NonCopyable(const NonCopyable& src) = delete; + NonCopyable& operator=(const NonCopyable& src) = delete; + + NonCopyable(NonCopyable&& src) = delete; + NonCopyable& operator=(NonCopyable&& src) = delete; + +private: + int m_val; +}; + +template +class transform_noncopyable_to_string +{ +public: + static decltype(auto) transform(T_element_from&& from) { return std::to_string(from.get_val()); } +}; + +void +test_tuple_transform_each_stdref_non_copyable() +{ + NonCopyable a(1); + NonCopyable b(2); + NonCopyable c(3); + auto t_original = std::make_tuple(std::ref(a), std::ref(b), std::ref(c)); + auto t_transformed = + sigc::internal::tuple_transform_each(t_original); + auto t_expected = std::make_tuple(std::string("1"), std::string("2"), std::string("3")); + + static_assert(std::tuple_size::value == 3, + "unexpected tuple_transform_each()ed tuple size."); + + assert(std::get<0>(t_transformed) == "1"); + assert(std::get<1>(t_transformed) == "2"); + assert(std::get<2>(t_transformed) == "3"); + + static_assert(std::is_same::value, + "unexpected transform_each()ed tuple type"); +} + +static std::string correct_sequence_output; + +template +class transform_each_correct_sequence +{ +public: + static decltype(auto) transform(int from) + { + correct_sequence_output += std::to_string(from); + return std::to_string(from); + } +}; + +void +test_tuple_transform_each_correct_sequence() +{ + correct_sequence_output.clear(); + auto t = std::make_tuple(1, 2, 3); + sigc::internal::tuple_transform_each(t); + // std::cout << "correct_sequence_output: " << correct_sequence_output << std::endl; + assert(correct_sequence_output == "123"); +} + +void +test_tuple_transform_each_empty_tuple() +{ + auto t = std::tuple<>(); + sigc::internal::tuple_transform_each(t); +} + +// The general template declaration. +// We then provide specializations for each type, +// so we can test having a different return value for each T_element_from type. +template +class transform_as_constexpr_to_something; + +// An int will be converted to a char: +template<> +class transform_as_constexpr_to_something +{ +public: + constexpr static char transform(int from) { return 'a' + static_cast(from); } +}; + +// A double will be converted to an int: +template<> +class transform_as_constexpr_to_something +{ +public: + constexpr static int transform(double from) { return (int)from; } +}; + +/* TODO: See the comment in main(). +constexpr +void +test_tuple_transform_each_constexpr() { + constexpr auto t_original = std::make_tuple(1, static_cast(2.1f)); + constexpr auto t_transformed = + sigc::internal::tuple_transform_each(t_original); + constexpr auto t_expected = std::make_tuple('b', 2); + + static_assert(std::tuple_size::value == 2, + "unexpected tuple_transform_each()ed tuple size."); + + assert(std::get<0>(t_transformed) == 'b'); + assert(std::get<1>(t_transformed) == 2); + + static_assert( + std::is_same::value, + "unexpected transform_each()ed tuple type"); +} +*/ + +int +main() +{ + test_tuple_transform_each_same_types(); + test_tuple_transform_each_multiple_types(); + + test_tuple_transform_each_nonconst(); + + test_tuple_transform_each_stdref(); + test_tuple_transform_each_stdref_non_copyable(); + + test_tuple_transform_each_correct_sequence(); + + test_tuple_transform_each_empty_tuple(); + + // g++ 5.2.1 gives this error: + // error: accessing uninitialized member ‘std::tuple::’ + // though it works with clang++. + // TODO: Try it with a newer g++. + // test_tuple_transform_each_constexpr(); + + return EXIT_SUCCESS; +} diff --git a/tests/test_visit_each.cc b/tests/test_visit_each.cc index a63fa435..adb59da8 100644 --- a/tests/test_visit_each.cc +++ b/tests/test_visit_each.cc @@ -1,4 +1,4 @@ -/* Copyright (C) 2014 The libsigc++ Development Team +/* Copyright (C) 2014 - 2016, The libsigc++ Development Team * * This file is part of libsigc++. * @@ -17,11 +17,9 @@ */ #include "testutilities.h" -#include #include -#include -#include #include +#include // SIGCTEST_CASE 1 Assume that class sigc::visitor has not been implemented. // Don't test with MyClass2, which is expected to fail in this case. @@ -44,8 +42,9 @@ class NsExtClass { }; -template -void visit_each(T_action&, const T_functor&) +template +void +visit_each(T_action&, const T_functor&) { result_stream << "ns_ext::visit_each() "; } @@ -57,25 +56,23 @@ namespace class MyClass1 : public sigc::trackable { public: - MyClass1(const std::string& str) : s(str) {} + explicit MyClass1(const std::string& str) : s(str) {} + + void execute(int i) { result_stream << s << i; } - void execute(int i) - { - result_stream << s << i; - } private: std::string s; }; -class MyClass2 : public ns_ext::NsExtClass, public sigc::trackable +class MyClass2 +: public ns_ext::NsExtClass +, public sigc::trackable { public: - MyClass2(const std::string& str) : s(str) {} + explicit MyClass2(const std::string& str) : s(str) {} + + void execute(int i) { result_stream << s << i; } - void execute(int i) - { - result_stream << s << i; - } private: std::string s; }; @@ -85,55 +82,46 @@ class MyClass2 : public ns_ext::NsExtClass, public sigc::trackable namespace ns1 { // User-defined adaptor, as decribed in adaptor_trait.h. -template +template struct MyAdaptor1 : public sigc::adapts { - template - struct deduce_result_type - { typedef sigc::deduce_result_t type; }; - typedef typename sigc::functor_trait::result_type result_type; - - result_type - operator()() const + decltype(auto) operator()() const { result_stream << "MyAdaptor1()() "; return this->functor_(); } - template - typename deduce_result_type::type - operator()(T_arg1 _A_arg1) const + template + decltype(auto) operator()(T_arg1 arg1) const { - result_stream << "MyAdaptor1()(_A_arg1) "; - return this->functor_(_A_arg1); + result_stream << "MyAdaptor1()(arg1) "; + return this->functor_(arg1); } - template - typename deduce_result_type::type - operator()(T_arg1 _A_arg1, T_arg2 _A_arg2) const + template + decltype(auto) operator()(T_arg1 arg1, T_arg2 arg2) const { - result_stream << "MyAdaptor1()(_A_arg1, _A_arg2) "; - return this->functor_(_A_arg1, _A_arg2); + result_stream << "MyAdaptor1()(arg1, arg2) "; + return this->functor_(arg1, arg2); } // Constructs a MyAdaptor1 object that wraps the passed functor. // Initializes adapts::functor_, which is invoked from operator()(). - explicit MyAdaptor1(const T_functor& _A_functor) - : sigc::adapts(_A_functor) {} + explicit MyAdaptor1(const T_functor& functor) : sigc::adapts(functor) {} }; -template -void visit_each(const T_action& _A_action, - const MyAdaptor1& _A_target) +template +void +visit_each(const T_action& action, const MyAdaptor1& target) { - visit_each(_A_action, _A_target.functor_); + visit_each(action, target.functor_); } -template +template inline MyAdaptor1 -my_adaptor1(const T_functor& _A_func) +my_adaptor1(const T_functor& func) { - return MyAdaptor1(_A_func); + return MyAdaptor1(func); } } // end namespace ns1 @@ -142,32 +130,31 @@ my_adaptor1(const T_functor& _A_func) // Specialization of sigc::visitor for MyAdaptor1. namespace sigc { -template -struct visitor > +template +struct visitor> { - template - static void do_visit_each(const T_action& _A_action, - const ns1::MyAdaptor1& _A_target) + template + static void do_visit_each(const T_action& action, const ns1::MyAdaptor1& target) { - sigc::visit_each(_A_action, _A_target.functor_); + sigc::visit_each(action, target.functor_); } }; } // end namespace sigc #endif // SIGCTEST_CASE >= 3 - -int main(int argc, char* argv[]) +int +main(int argc, char* argv[]) { auto util = TestUtilities::get_instance(); if (!util->check_command_args(argc, argv)) return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; - sigc::slot sl1; + sigc::slot sl1; { MyClass1 my_class1("x="); - sl1 = sigc::mem_fun(&my_class1, &MyClass1::execute); + sl1 = sigc::mem_fun(my_class1, &MyClass1::execute); sl1(-2); util->check_result(result_stream, "x=-2"); @@ -179,7 +166,7 @@ int main(int argc, char* argv[]) #if SIGCTEST_CASE >= 2 { MyClass2 my_class2("y="); - sl1 = sigc::mem_fun(&my_class2, &MyClass2::execute); + sl1 = sigc::mem_fun(my_class2, &MyClass2::execute); sl1(2); util->check_result(result_stream, "y=2"); @@ -191,9 +178,9 @@ int main(int argc, char* argv[]) { MyClass1 my_class3("a="); - sl1 = ns1::my_adaptor1(sigc::mem_fun(&my_class3, &MyClass1::execute)); + sl1 = ns1::my_adaptor1(sigc::mem_fun(my_class3, &MyClass1::execute)); sl1(42); - util->check_result(result_stream, "MyAdaptor1()(_A_arg1) a=42"); + util->check_result(result_stream, "MyAdaptor1()(arg1) a=42"); } // auto-disconnect sl1 diff --git a/tests/test_visit_each_trackable.cc b/tests/test_visit_each_trackable.cc new file mode 100644 index 00000000..720fcfbd --- /dev/null +++ b/tests/test_visit_each_trackable.cc @@ -0,0 +1,101 @@ +/* Copyright 2002 - 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + +#include "testutilities.h" +#include +#include //For std::ref(). +#include +#include +#include +#include +#include + +namespace +{ + +TestUtilities* util = nullptr; +std::ostringstream result_stream; + +struct A : public sigc::trackable +{ + A() {} +}; + +template::value> +struct with_trackable; + +template +struct with_trackable +{ + static void perform(const T_type&) { result_stream << "other "; } +}; + +template +struct with_trackable +{ + static void perform(const T_type&) { result_stream << "trackable "; } + + static void perform(T_type*) { result_stream << "trackable* "; } + + static void perform(const T_type*) { result_stream << "const trackable* "; } +}; + +struct print +{ + void operator()(int i) const { result_stream << "int: " << i << " "; } + + template + void operator()(const T& t) const + { + with_trackable::perform(t); + } +}; + +void +foo(int, int, int) +{ +} + +void +bar(int) +{ +} + +} // end anonymous namespace + +void +test_hit_all_targets() +{ + int i = 1; + A a; + result_stream << "hit all targets: "; + sigc::visit_each( + print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), std::ref(a), i), sigc::ptr_fun(&bar))); + util->check_result(result_stream, "hit all targets: other trackable int: 1 other "); +} + +void +test_hit_all_trackable() +{ + int i = 3; + A a; + result_stream << "hit all trackable: "; + sigc::visit_each_trackable( + print(), sigc::compose(sigc::bind(sigc::ptr_fun(&foo), std::ref(a), i), sigc::ptr_fun(&bar))); + util->check_result(result_stream, "hit all trackable: trackable "); +} + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_hit_all_targets(); + test_hit_all_trackable(); + + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/test_weak_raw_ptr.cc b/tests/test_weak_raw_ptr.cc new file mode 100644 index 00000000..c6ffc38d --- /dev/null +++ b/tests/test_weak_raw_ptr.cc @@ -0,0 +1,72 @@ +/* Copyright 2016, The libsigc++ Development Team + * Assigned to public domain. Use as you wish without restriction. + */ + +#include "testutilities.h" +#include +#include + +namespace +{ + +TestUtilities* util = nullptr; +std::ostringstream result_stream; + +class A : public sigc::trackable +{ +public: + void something() { result_stream << "method called"; } +}; + +} // end anonymous namespace + +void +test_weak_ptr_becomes_null() +{ + const auto a = new A(); + sigc::internal::weak_raw_ptr raw_ptr(a); + assert(raw_ptr); + + // Call something on A, via the weak_raw_ptr<>, + // just to make sure that it doesn't get optimised away: + raw_ptr->something(); + util->check_result(result_stream, "method called"); + + delete a; + + // Deleting the A should have made the weak_raw_ptr become invalid. + assert(!raw_ptr); +} + +void +test_weak_ptr_disconnects_self() +{ + const auto a = new A(); + { + sigc::internal::weak_raw_ptr raw_ptr(a); + + // Call something on A, via the weak_raw_ptr<>, + // just to make sure that it doesn't get optimised away: + raw_ptr->something(); + util->check_result(result_stream, "method called"); + } + + // If the weak_raw_ptr has not asked A to stop notifying it, + // then we would expect some undefined behaviour here, + // when a tries to notify the now-destroyed weak_raw_ptr. + delete a; +} + +int +main(int argc, char* argv[]) +{ + util = TestUtilities::get_instance(); + + if (!util->check_command_args(argc, argv)) + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; + + test_weak_ptr_becomes_null(); + test_weak_ptr_disconnects_self(); + + return util->get_result_and_delete_instance() ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/tests/testutilities.cc b/tests/testutilities.cc index 4d8de22c..ae9e11c0 100644 --- a/tests/testutilities.cc +++ b/tests/testutilities.cc @@ -1,4 +1,4 @@ -/* Copyright (C) 2012 The libsigc++ Development Team +/* Copyright (C) 2012 - 2016, The libsigc++ Development Team * * This file is part of libsigc++. * @@ -23,13 +23,11 @@ TestUtilities* TestUtilities::instance_ = nullptr; -TestUtilities::TestUtilities() -: verbose_(false), result_ok_(true), test_number_(0) -{ -} +TestUtilities::TestUtilities() : verbose_(false), result_ok_(true), test_number_(0) {} -//static -TestUtilities* TestUtilities::get_instance() +// static +TestUtilities* +TestUtilities::get_instance() { if (!instance_) instance_ = new TestUtilities; @@ -37,7 +35,8 @@ TestUtilities* TestUtilities::get_instance() return instance_; } -bool TestUtilities::check_command_args(int argc, char* argv[]) +bool +TestUtilities::check_command_args(int argc, char* argv[]) { bool go_on = true; // Whether the caller shall continue program execution. bool print_help = false; @@ -65,8 +64,8 @@ bool TestUtilities::check_command_args(int argc, char* argv[]) return go_on; } -void TestUtilities::check_result(std::ostringstream& result_stream, - const std::string& expected_result) +void +TestUtilities::check_result(std::ostringstream& result_stream, const std::string& expected_result) { if (verbose_) std::cout << result_stream.str() << std::endl; @@ -82,8 +81,9 @@ void TestUtilities::check_result(std::ostringstream& result_stream, result_stream.str(""); } -//static -bool TestUtilities::get_result_and_delete_instance() +// static +bool +TestUtilities::get_result_and_delete_instance() { const bool result = instance_ ? instance_->result_ok_ : true; delete instance_; diff --git a/tests/testutilities.h b/tests/testutilities.h index f06d6d90..772689dc 100644 --- a/tests/testutilities.h +++ b/tests/testutilities.h @@ -24,7 +24,6 @@ class TestUtilities { public: - // Non-copyable: TestUtilities(const TestUtilities&) = delete; TestUtilities& operator=(const TestUtilities&) = delete; @@ -44,8 +43,6 @@ class TestUtilities static bool get_result_and_delete_instance(); private: - - TestUtilities(); static TestUtilities* instance_; diff --git a/tools/handle-built-files.py b/tools/handle-built-files.py new file mode 100644 index 00000000..fc1f9b6f --- /dev/null +++ b/tools/handle-built-files.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 + +# External command, intended to be called with run_command(), custom_target(), +# meson.add_install_script() and meson.add_dist_script(). + +# argv[1] argv[2:] +# handle-built-files.py ... + +import os +import sys +import shutil +import subprocess +from pathlib import Path + +subcommand = sys.argv[1] + +# Invoked from meson.add_dist_script(). +def dist_built_files(is_msvc_files=False): + # argv[2] argv[3] argv[4:] + # ... + + # is an absolute path in the build directory or source directory. + # is a distribution directory, relative to MESON_PROJECT_DIST_ROOT. + + # MESON_PROJECT_DIST_ROOT is set only if meson.version() >= 0.58.0. + project_dist_root = os.getenv('MESON_PROJECT_DIST_ROOT', os.getenv('MESON_DIST_ROOT')) + built_h_cc_dir = sys.argv[2] + dist_dir_root = os.path.join(project_dist_root, sys.argv[3]) + dist_dir = dist_dir_root + + # Distribute .h and .cc files built from .m4 files, or generated MSVC files. + for file in sys.argv[4:]: + if not is_msvc_files: + dist_dir = os.path.join(dist_dir_root, os.path.dirname(file)) + + # Create the distribution directory, if it does not exist. + os.makedirs(dist_dir, exist_ok=True) + + shutil.copy(os.path.join(built_h_cc_dir, file), dist_dir) + return 0 + +# ----- Main ----- +if subcommand == 'dist_gen_msvc_files': + sys.exit(dist_built_files(True)) +print(sys.argv[0], ': illegal subcommand,', subcommand) +sys.exit(1) diff --git a/tools/tutorial-custom-cmd.py b/tools/tutorial-custom-cmd.py new file mode 100755 index 00000000..280d2559 --- /dev/null +++ b/tools/tutorial-custom-cmd.py @@ -0,0 +1,216 @@ +#!/usr/bin/env python3 + +# External command, intended to be called with custom_target() in meson.build + +# argv[1] argv[2:] +# tutorial-custom-cmd.py ... + +import os +import sys +import subprocess +import shutil + +subcommand = sys.argv[1] + +def html(): + # argv[2] argv[3] + # + + input_xml_file = sys.argv[2] + output_html_dir = sys.argv[3] + + # Set the use.id.as.filename param so that we don't use the chapter / section + # number as the filename, otherwise the url will change every time anything is + # re-ordered or inserted in the documentation. + # For a list of available parameters, see http://docbook.sourceforge.net/release/xsl/current/doc/html/ + xslt_params = [ + '--param', 'toc.section.depth', '1', + '--stringparam', 'chunker.output.indent', 'yes', + '--stringparam', 'chunker.output.encoding', 'UTF-8', + '--stringparam', 'toc.list.type', 'ul', + '--param', 'use.id.as.filename', '1', + ] + + # The recommended stylesheet for DocBook V5.0 is .../xsl-ns/... + # It's not used here because the docbook-xsl-ns package is not available + # when building with gnome-build-meta. + xslt_stylesheet = 'http://docbook.sourceforge.net/release/xsl/current/html/chunk.xsl' + + # Remove old files and create the destination directory. + shutil.rmtree(output_html_dir, ignore_errors=True) + os.makedirs(output_html_dir, exist_ok=True) + + cmd = [ + 'xsltproc', + ] + xslt_params + [ + '-o', output_html_dir + '/', + '--xinclude', + xslt_stylesheet, + input_xml_file, + ] + result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + universal_newlines=True) + # xsltproc prints the names of all written files. Don't print those lines. + for line in result.stdout.splitlines(): + if not line.startswith('Writing '): + print(line) + + return result.returncode + +def xmllint(): + from pathlib import Path + + # argv[2] argv[3] argv[4] + # + + validate = sys.argv[2] + input_xml_file = sys.argv[3] + stamp_file_path = sys.argv[4] + + relax_ng_schema = 'http://docbook.org/xml/5.0/rng/docbook.rng' + # schematron_schema = 'http://docbook.org/xml/5.0/sch/docbook.sch' + + # Validation against the Schematron schema does not work on Ubuntu 21.04: + # file:///usr/share/xml/docbook/schema/schematron/5.0/docbook.sch:6: element rule: + # Schemas parser error : Failed to compile context expression db:firstterm[@linkend] + # ..... + # Schematron schema http://docbook.org/xml/5.0/sch/docbook.sch failed to compile + + cmd = [ + 'xmllint', + '--noout', + '--noent', + '--xinclude', + ] + if validate == 'true': + cmd += [ + '--relaxng', relax_ng_schema, + #'--schematron', schematron_schema, + ] + cmd += [input_xml_file] + result = subprocess.run(cmd) + if result.returncode: + return result.returncode + + Path(stamp_file_path).touch(exist_ok=True) + return 0 + +# dblatex and xsltproc+fop generate a PDF file. +# docbook2pdf can generate PDF files from DocBook4 files, but not from DocBook5 files. +# xsltproc+xmlroff (version 0.6.3) does not seem to work acceptably. +def dblatex(): + # argv[2] argv[3] + # + # Create a PDF file, using dblatex. + + input_xml_file = sys.argv[2] + output_pdf_file = sys.argv[3] + + # For a list of available parameters, see http://dblatex.sourceforge.net/doc/manual/ + dblatex_params = [ + '-P', 'toc.section.depth=1', + '-P', 'paper.type=a4paper', + '-P', 'doc.collab.show=1', + '-P', 'latex.output.revhistory=0', + '-P', 'latex.engine.options="-halt-on-error"', + ] + + cmd = [ + 'dblatex', + ] + dblatex_params + [ + '-o', output_pdf_file, + '--pdf', + input_xml_file, + ] + return subprocess.run(cmd).returncode + +def fop(): + # argv[2] argv[3] + # + # Create a PDF file, using fop. + + input_xml_file = sys.argv[2] + output_pdf_file = sys.argv[3] + + fo_file = os.path.splitext(output_pdf_file)[0] + '.fo' + + # For a list of available parameters, see http://docbook.sourceforge.net/release/xsl/current/doc/fo/ + # For a list of available paper types, see the description of the page.width.portrait parameter. + xslt_params = [ + '--param', 'toc.section.depth', '1', + '--stringparam', 'fop1.extensions', '1', + '--stringparam', 'page.orientation', 'portrait', + '--stringparam', 'paper.type', 'A4', + ] + + xslt_stylesheet = 'http://docbook.sourceforge.net/release/xsl/current/fo/docbook.xsl' + + # Generate a .fo (formatting object) file. + # fop can take an xslt stylesheet parameter, but it can only read local files. + # xsltproc is necessary if you want to read the stylesheet from the internet. + cmd = [ + 'xsltproc', + ] + xslt_params + [ + '-o', fo_file, + '--xinclude', + xslt_stylesheet, + input_xml_file, + ] + result = subprocess.run(cmd) + if result.returncode: + return result.returncode + + cmd = [ + 'fop', + '-fo', fo_file, + '-pdf', output_pdf_file, + ] + return subprocess.run(cmd).returncode + +# Invoked from meson.add_dist_script(). +def dist_doc(): + # argv[2] argv[3] argv[4] argv[5] + # + + # is a distribution directory, relative to MESON_PROJECT_DIST_ROOT. + # is a relative or absolute path in the build directory. + # is a relative or absolute path in the source directory. + # is a relative or absolute path in the build directory. + + # MESON_PROJECT_DIST_ROOT is set only if meson.version() >= 0.58.0. + project_dist_root = os.getenv('MESON_PROJECT_DIST_ROOT', os.getenv('MESON_DIST_ROOT')) + doc_dist_dir = os.path.join(project_dist_root, sys.argv[2]) + doc_build_dir = sys.argv[3] + xml_file = sys.argv[4] + pdf_file = sys.argv[5] + + # Create the distribution directory, if it does not exist. + os.makedirs(doc_dist_dir, exist_ok=True) + + # Distribute built html files. + shutil.copytree(os.path.join(doc_build_dir, 'html'), + os.path.join(doc_dist_dir, 'html'), + copy_function=shutil.copy) + + # If there is an updated PDF file, distribute it. + if os.path.isfile(pdf_file) and \ + os.stat(pdf_file).st_mtime > os.stat(xml_file).st_mtime: + shutil.copy(pdf_file, doc_dist_dir) + else: + print('--- Info: No updated PDF file found.') + + return 0 + +# ----- Main ----- +if subcommand == 'html': + sys.exit(html()) +if subcommand == 'xmllint': + sys.exit(xmllint()) +if subcommand == 'dblatex': + sys.exit(dblatex()) +if subcommand == 'fop': + sys.exit(fop()) +if subcommand == 'dist_doc': + sys.exit(dist_doc()) +print(sys.argv[0], ': illegal subcommand,', subcommand) +sys.exit(1) diff --git a/untracked/README b/untracked/README new file mode 100644 index 00000000..dfefb62b --- /dev/null +++ b/untracked/README @@ -0,0 +1,36 @@ +untracked/README + +This directory contains files not tracked by a source code control program, +such as git. (This README file is the exception.) + +The files can have one of two origins. + +1. Copied by the mm-common-get command. +2. Generated when libsigc++ is built. + +Files of type 2 exist here only if libsigc++ is built with maintainer-mode=false, +or the directory comes from a tarball. +Files of both types exist here only if libsigc++ is built with Meson, +or the tarball is created with Meson. + +1. Files copied by mm-common-get +-------------------------------- +untracked/docs/docs/doc_install.py or doc-install.pl + doc_postprocess.py or doc-postprocess.pl + doxygen-extra.css + tagfile-to-devhelp2.xsl +untracked/build_scripts/dist-build-scripts.py + dist-changelog.py + doc-reference.py + +mm-common-get may copy more files, but they are not used by libsigc++. + +2. Generated files +------------------ +untracked/docs/docs/reference/libsigc++-3.0.devhelp2 + libsigc++-3.0.tag + html/* +untracked/docs/docs/manual/libsigc_manual.pdf (only if build-pdf=true) + html/* +untracked/MSVC_NMake/sigc.rc + sigc++config.h